Aminet 48/Aminet 48 (2002)(GTI - Schatztruhe)[!][Apr 2002].iso/Aminet/text/edit/vim60rt.lha/Vim/vim60/doc/eval.txt

Text File | 2001-09-26 | 117.9 KB | 3,111 lines

*eval.txt*      For Vim version 6.0.  Last change: 2001 Sep 16


          VIM REFERENCE MANUAL    by Bram Moolenaar


Expression evaluation            *expression* *expr* *E15* *eval*

Using expressions is introduced in chapter 41 of the user manual |usr_41.txt|.

Note: Expression evaluation can be disabled at compile time.  If this has been
done, the features in this document are not available.  See |+eval| and the
last chapter below.

1. Variables        |variables|
2. Expression syntax    |expression-syntax|
3. Internal variable    |internal-variables|
4. Builtin Functions    |functions|
5. Defining functions    |user-functions|
6. Curly braces names    |curly-braces-names|
7. Commands        |expression-commands|
8. Examples        |eval-examples|
9. No +eval feature    |no-eval-feature|
10. The sandbox        |eval-sandbox|

{Vi does not have any of these commands}

==============================================================================
1. Variables                        *variables*

There are two types of variables:

Number        a 32 bit signed number.
String        a NUL terminated string of 8-bit unsigned characters.

These are converted automatically, depending on how they are used.

Conversion from a Number to a String is by making the ASCII representation of
the Number.  Examples: >
Number 123    -->    String "123"
Number 0    -->    String "0"
Number -1    -->    String "-1"

Conversion from a String to a Number is done by converting the first digits
to a number.  Hexadecimal "0xf9" and Octal "017" numbers are recognized.  If
the String doesn't start with digits, the result is zero.  Examples: >
String "456"    -->    Number 456
String "6bar"    -->    Number 6
String "foo"    -->    Number 0
String "0xf1"    -->    Number 241
String "0100"    -->    Number 64

To force conversion from String to Number, add zero to it: >
:echo "0100" + 0

For boolean operators Numbers are used.  Zero is FALSE, non-zero is TRUE.

Note that in the command >
:if "foo"
"foo" is converted to 0, which means FALSE.  To test for a non-empty string,
use strlen(): >
:if strlen("foo")

If you need to know the type of a variable or expression, use the |type()|
function.

When the '!' flag is included in the 'viminfo' option, global variables that
start with an uppercase letter, and don't contain a lowercase letter, are
stored in the viminfo file |viminfo-file|.

When the 'sessionoptions' option contains "global", global variables that
start with an uppercase letter and contain at least one lowercase letter are
stored in the session file |session-file|.

variable name        can be stored where ~
my_var_6        not
My_Var_6        session file
MY_VAR_6        viminfo file


It's possible to form a variable name with curly braces, see
|curly-braces-names|.

==============================================================================
2. Expression syntax                    *expression-syntax*

Expression syntax summary, from least to most significant:

|expr1| expr2 ? expr1 : expr1    if-then-else

|expr2|    expr3 || expr3 ..    logical OR

|expr3|    expr4 && expr4 ..    logical AND

|expr4|    expr5 == expr5        equal
expr5 != expr5        not equal
expr5 >     expr5        greater than
expr5 >= expr5        greater than or equal
expr5 <     expr5        smaller than
expr5 <= expr5        smaller than or equal
expr5 =~ expr5        regexp matches
expr5 !~ expr5        regexp doesn't match
expr5 ==? expr5        equal, ignoring case
expr5 ==# expr5        equal, match case
etc.  As above, append ? for ignoring case, # for matching case

|expr5|    expr6 +     expr6 ..    number addition
expr6 -     expr6 ..    number subtraction
expr6 .     expr6 ..    string concatenation

|expr6|    expr7 *     expr7 ..    number multiplication
expr7 /     expr7 ..    number division
expr7 %     expr7 ..    number modulo

|expr7|    ! expr7            logical NOT
- expr7            unary minus
+ expr7            unary plus
expr8

|expr8|    expr9[expr1]        index in String

|expr9|    number            number constant
"string"        string constant
'string'        literal string constant
&option            option value
(expr1)            nested expression
variable        internal variable
va{ria}ble        internal variable with curly braces
$VAR            environment variable
@r            contents of register 'r'
function(expr1, ...)    function call
func{ti}on(expr1, ...)    function call with curly braces


".." indicates that the operations in this level can be concatenated.
Example: >
&nu || &list && &shell == "csh"

All expressions within one level are parsed from left to right.


expr1                            *expr1* *E109*
-----

expr2 ? expr1 : expr1

The expression before the '?' is evaluated to a number.  If it evaluates to
non-zero, the result is the value of the expression between the '?' and ':',
otherwise the result is the value of the expression after the ':'.
Example: >
:echo lnum == 1 ? "top" : lnum

Since the first expression is an "expr2", it cannot contain another ?:.  The
other two expressions can, thus allow for recursive use of ?:.
Example: >
:echo lnum == 1 ? "top" : lnum == 1000 ? "last" : lnum

To keep this readable, using |line-continuation| is suggested: >
:echo lnum == 1
:\    ? "top"
:\    : lnum == 1000
:\        ? "last"
:\        : lnum


expr2 and expr3                        *expr2* *expr3*
---------------

                    *expr-barbar* *expr-&&*
The "||" and "&&" operators take one argument on each side.  The arguments
are (converted to) Numbers.  The result is:

 input                 output ~
n1        n2        n1 || n2    n1 && n2 ~
zero        zero        zero        zero
zero        non-zero    non-zero    zero
non-zero    zero        non-zero    zero
non-zero    non-zero    non-zero    non-zero

The operators can be concatenated, for example: >

&nu || &list && &shell == "csh"

Note that "&&" takes precedence over "||", so this has the meaning of: >

&nu || (&list && &shell == "csh")

Once the result is known, the expression "short-circuits", that is, further
arguments are not evaluated.  This is like what happens in C.  For example: >

let a = 1
echo a || b

This is valid even if there is no variable called "b" because "a" is non-zero,
so the result must be non-zero.  Similarly below: >

echo exists("b") && b == "yes"

This is valid whether "b" has been defined or not.  The second clause will
only be evaluated if "b" has been defined.


expr4                            *expr4*
-----

expr5 {cmp} expr5

Compare two expr5 expressions, resulting in a 0 if it evaluates to false, or 1
if it evaluates to true.

            *expr-==*  *expr-!=*  *expr->*   *expr->=*
            *expr-<*   *expr-<=*  *expr-=~*  *expr-!~*
            *expr-==#* *expr-!=#* *expr->#*  *expr->=#*
            *expr-<#*  *expr-<=#* *expr-=~#* *expr-!~#*
            *expr-==?* *expr-!=?* *expr->?*  *expr->=?*
            *expr-<?*  *expr-<=?* *expr-=~?* *expr-!~?*
        use 'ignorecase'    match case       ignore case ~
equal            ==        ==#        ==?
not equal        !=        !=#        !=?
greater than        >        >#        >?
greater than or equal    >=        >=#        >=?
smaller than        <        <#        <?
smaller than or equal    <=        <=#        <=?
regexp matches        =~        =~#        =~?
regexp doesn't match    !~        !~#        !~?

Examples:
"abc" ==# "Abc"      evaluates to 0
"abc" ==? "Abc"      evaluates to 1
"abc" == "Abc"      evaluates to 1 if 'ignorecase' is set, 0 otherwise

When comparing a String with a Number, the String is converted to a Number,
and the comparison is done on Numbers.

When comparing two Strings, this is done with strcmp() or stricmp().  This
results in the mathematical difference (comparing byte values), not
necessarily the alphabetical difference in the local language.

When using the operators with a trailing '#", or the short version and
'ignorecase' is off, the comparing is done with strcmp().

When using the operators with a trailing '?', or the short version and
'ignorecase' is set, the comparing is done with stricmp().

The "=~" and "!~" operators match the lefthand argument with the righthand
argument, which is used as a pattern.  See |pattern| for what a pattern is.
This matching is always done like 'magic' was set and 'cpoptions' is empty, no
matter what the actual value of 'magic' or 'cpoptions' is.  This makes scripts
portable.  To avoid backslashes in the regexp pattern to be doubled, use a
single-quote string, see |literal-string|.
Since a string is considered to be a single line, a multi-line pattern
(containing \n, backslash-n) will not match.  However, a literal NL character
can be matched like an ordinary character.  Examples:
"foo\nbar" =~ "\n"    evaluates to 1
"foo\nbar" =~ "\\n"    evaluates to 0


expr5 and expr6                        *expr5* *expr6*
---------------
expr6 +     expr6 ..    number addition        *expr-+*
expr6 -     expr6 ..    number subtraction    *expr--*
expr6 .     expr6 ..    string concatenation    *expr-.*

expr7 *     expr7 ..    number multiplication    *expr-star*
expr7 /     expr7 ..    number division        *expr-/*
expr7 %     expr7 ..    number modulo        *expr-%*

For all, except ".", Strings are converted to Numbers.

Note the difference between "+" and ".":
"123" + "456" = 579
"123" . "456" = "123456"

When the righthand side of '/' is zero, the result is 0xfffffff.
When the righthand side of '%' is zero, the result is 0.


expr7                            *expr7*
-----
! expr7            logical NOT        *expr-!*
- expr7            unary minus        *expr-unary--*
+ expr7            unary plus        *expr-unary-+*

For '!' non-zero becomes zero, zero becomes one.
For '-' the sign of the number is changed.
For '+' the number is unchanged.

A String will be converted to a Number first.

These three can be repeated and mixed.  Examples:
!-1        == 0
!!8        == 1
--9        == 9


expr8                            *expr8*
-----
expr9[expr1]        index in String        *expr-[]* *E111*

This results in a String that contains the expr1'th single character from
expr9.  expr9 is used as a String, expr1 as a Number.

Note that index zero gives the first character.  This is like it works in C.
Careful: text column numbers start with one!  Example, to get the character
under the cursor: >
:let c = getline(line("."))[col(".") - 1]

If the length of the String is less than the index, the result is an empty
String.

                        *expr9*
number
------
number            number constant        *expr-number*

Decimal, Hexadecimal (starting with 0x or 0X), or Octal (starting with 0).


string                            *expr-string* *E114*
------
"string"        string constant        *expr-quote*

Note that double quotes are used.

A string constant accepts these special characters:
\...    three-digit octal number (e.g., "\316")
\..    two-digit octal number (must be followed by non-digit)
\.    one-digit octal number (must be followed by non-digit)
\x..    two-character hex number (e.g., "\x1f")
\x.    one-character hex number (must be followed by non-hex)
\X..    same as \x..
\X.    same as \x.
\b    backspace <BS>
\e    escape <Esc>
\f    formfeed <FF>
\n    newline <NL>
\r    return <CR>
\t    tab <Tab>
\\    backslash
\"    double quote
\<xxx>    Special key named "xxx".  e.g. "\<C-W>" for CTRL-W.

Note that "\000" and "\x00" force the end of the string.


literal-string                        *literal-string* *E115*
---------------
'string'        literal string constant        *expr-'*

Note that single quotes are used.

This string is taken literally.  No backslashes are removed or have a special
meaning.  A literal-string cannot contain a single quote.  Use a normal string
for that.


option                        *expr-option* *E112* *E113*
------
&option            option value

Any option name can be used here.  See |options|.  This sets the buffer-local
or window-local value if there is one.


register                        *expr-register*
--------
@r            contents of register 'r'

The result is the contents of the named register, as a single string.
Newlines are inserted where required.  To get the contents of the unnamed
register use @@.  The '=' register can not be used here.  See |registers| for
an explanation of the available registers.


nesting                            *expr-nesting* *E110*
-------
(expr1)            nested expression


environment variable                    *expr-env*
--------------------
$VAR            environment variable

The String value of any environment variable.  When it is not defined, the
result is an empty string.
                        *expr-env-expand*
Note that there is a difference between using $VAR directly and using
expand("$VAR").  Using it directly will only expand environment variables that
are known inside the current Vim session.  Using expand() will first try using
the environment variables known inside the current Vim session.  If that
fails, a shell will be used to expand the variable.  This can be slow, but it
does expand all variables that the shell knows about.  Example: >
:echo $version
:echo expand("$version")
The first one probably doesn't echo anything, the second echoes the $version
variable (if your shell supports it).


internal variable                    *expr-variable*
-----------------
variable        internal variable
See below |internal-variables|.


function call        *expr-function* *E116* *E117* *E118* *E119* *E120*
-------------
function(expr1, ...)    function call
See below |functions|.


==============================================================================
3. Internal variable                *internal-variables* *E121*

An internal variable name can be made up of letters, digits and '_'.  But it
cannot start with a digit.  It's also possible to use curly braces, see
|curly-braces-names|.

An internal variable is created with the ":let" command |:let|.
An internal variable is destroyed with the ":unlet" command |:unlet|.
Using a name that isn't an internal variable, or an internal variable that has
been destroyed, results in an error.

There are several name spaces for variables.  Which one is to be used is
specified by what is prepended::

    (nothing) In a function: local to a function; Otherwise: global
|buffer-variable|    b:      Local to the current buffer.
|window-variable|    w:      Local to the current window.
|global-variable|    g:      Global.
|local-variable|     l:      Local to a function.
|script-variable|    s:      Local to a |:source|'ed Vim script.
|function-argument|  a:      Function argument (only inside a function).
|vim-variable|       v:      Global, predefined by Vim.

                        *buffer-variable* *b:var*
A variable name that is preceded with "b:" is local to the current buffer.
Thus you can have several "b:foo" variables, one for each buffer.
This kind of variable is deleted when the buffer is unloaded.  If you want to
keep it, avoid that the buffer is unloaded by setting the 'hidden' option.

One local buffer variable is predefined:
                    *b:changedtick-variable* *changetick*
b:changedtick    The total number of changes to the current buffer.  It is
        incremented for each change.  An undo command is also a change
        in this case.  This can be used to perform an action only when
        the buffer has changed.  Example: >
            :if my_changedtick != b:changedtick
            :   let my_changedtick = b:changedtick
            :   call My_Update()
            :endif
<
                        *window-variable* *w:var*
A variable name that is preceded with "w:" is local to the current window.  It
is deleted when the window is closed.

                        *global-variable* *g:var*
Inside functions global variables are accessed with "g:".  Omitting this will
access a variable local to a function.  But "g:" can also be used in any other
place if you like.

                        *local-variable* *l:var*
Inside functions local variables are accessed without prepending anything.
But you can also prepend "l:" if you like.

                        *script-variable* *s:var*
In a Vim script variables starting with "s:" can be used.  They cannot be
accessed from outside of the scripts, thus are local to the script.

They can be used in:
- commands executed while the script is sourced
- functions defined in the script
- autocommands defined in the script
- functions and autocommands defined in functions and autocommands which were
  defined in the script (recursively)
- user defined commands defined in the script
Thus not in:
- other scripts sourced from this one
- mappings
- etc.

script variables can be used to avoid conflicts with global variable names.
An example that works: >

    let s:counter = 0
    function MyCounter()
      let s:counter = s:counter + 1
      echo s:counter
    endfunction
    command Tick call MyCounter()

And an example that does NOT work: >

    let s:counter = 0
    command Tick let s:counter = s:counter + 1 | echo s:counter

When the ":Tick" command is executed outside the script, the s:counter
variable will not be available.  In the previous example, calling the
MyCounter() function sets the context for script variables to where the
function was defined, then s:counter can be used.
The script variables are also available when a function is defined inside a
function that is defined in a script.  Example: >

    let s:counter = 0
    function StartCounting(incr)
      if a:incr
        function MyCounter()
          let s:counter = s:counter + 1
        endfunction
      else
        function MyCounter()
          let s:counter = s:counter - 1
        endfunction
      endif
    endfunction

This defines the MyCounter() function either for counting up or counting down
when calling StartCounting().  It doesn't matter from where StartCounting() is
called, the s:counter variable will be accessible in MyCounter().

When the same script is sourced again it will use the same script variables.
They will remain valid as long as Vim is running.  This can be used to
maintain a counter: >

    if !exists("s:counter")
      let s:counter = 1
      echo "script executed for the first time"
    else
      let s:counter = s:counter + 1
      echo "script executed " . s:counter . " times now"
    endif

Note that this means that filetype plugins don't get a different set of script
variables for each buffer.  Use local buffer variables instead |b:var|.


Predefined Vim variables:            *vim-variable* *v:var*

            *v:charconvert_from* *charconvert_from-variable*
v:charconvert_from
        The name of the character encoding of a file to be converted.
        Only valid while evaluating the 'charconvert' option.

            *v:charconvert_to* *charconvert_to-variable*
v:charconvert_to
        The name of the character encoding of a file after conversion.
        Only valid while evaluating the 'charconvert' option.

                    *v:fname_in* *fname_in-variable*
v:fname_in    The name of the input file.  Only valid while evaluating:
            option        used for ~
            'charconvert'    file to be converted
            'diffexpr'    original file
            'patchexpr'    original file
            'printexpr'    file to be printed

                    *v:fname_out* *fname_out-variable*
v:fname_out    The name of the output file.  Only valid while
        evaluating:
            option        used for ~
            'charconvert'    resulting converted file (*)
            'diffexpr'    output of diff
            'patchexpr'    resulting patched file
        (*) When doing conversion for a write command (e.g., ":w
        file") it will be equal to v:fname_in.  When doing conversion
        for a read command (e.g., ":e file") it will be a temporary
        file and different from v:fname_in.

                    *v:fname_new* *fname_new-variable*
v:fname_new    The name of the new version of the file.  Only valid while
        evaluating 'diffexpr'.

                    *v:fname_diff* *fname_diff-variable*
v:fname_diff    The name of the diff (patch) file.  Only valid while
        evaluating 'patchexpr'.

                    *v:cmdarg* *cmdarg-variable*
v:cmdarg    This variable is used for two purposes:
        1. The extra arguments given to a file read/write command.
           Currently these are "++enc=" and "++ff=".  This variable is
           set before an autocommand event for a file read/write
           command is triggered.  There is a leading space to make it
           possible to append this variable directly after the
           read/write command.  Note: The "+cmd" argument isn't
           included here, because it will be executed anyway.
        2. When printing a PostScript file with ":hardcopy" this is
           the argument for the ":hardcopy" command.  This can be used
           in 'printexpr'.

                    *v:count* *count-variable*
v:count        The count given for the last Normal mode command.  Can be used
        to get the count before a mapping.  Read-only.  Example: >
    :map _x :<C-U>echo "the count is " . v:count<CR>
<        Note: The <C-U> is required to remove the line range that you
        get when typing ':' after a count.
        "count" also works, for backwards compatibility.

                    *v:count1* *count1-variable*
v:count1    Just like "v:count", but defaults to one when no count is
        used.

                    *v:prevcount* *prevcount-variable*
v:prevcount    The count given for the last but one Normal mode command.
        This is the v:count value of the previous command.  Useful if
        you want to cancel Visual mode and then use the count. >
            :vmap % <Esc>:call MyFilter(v:prevcount)<CR>
<        Read-only.

                    *v:errmsg* *errmsg-variable*
v:errmsg    Last given error message.  It's allowed to set this variable.
        Example: >
    :let v:errmsg = ""
    :silent! next
    :if v:errmsg != ""
    :  ... handle error
<        "errmsg" also works, for backwards compatibility.

                    *v:folddashes* *folddashes-variable*
v:folddashes    Used for 'foldtext': dashes representing foldlevel of a closed
        fold.
        Read-only. |fold-foldtext|

                    *v:foldlevel* *foldlevel-variable*
v:foldlevel    Used for 'foldtext': foldlevel of closed fold.
        Read-only. |fold-foldtext|

                    *v:foldend* *foldend-variable*
v:foldend    Used for 'foldtext': last line of closed fold.
        Read-only. |fold-foldtext|

                    *v:foldstart* *foldstart-variable*
v:foldstart    Used for 'foldtext': first line of closed fold.
        Read-only. |fold-foldtext|

                    *v:progname* *progname-variable*
v:progname    Contains the name (with path removed) with which vim was
        invoked.  Allows you to do special initialisations for "view",
        "evim" etc., or any other name you might symlink to vim.
        Read-only.

                        *v:lang* *lang-variable*
v:lang        The current locale setting for messages of the runtime
        environment.  This allows Vim scripts to be aware of the
        current language.  Technical: it's the value of LC_MESSAGES.
        This variable can not be set directly, use the |:language|
        command.
        It can be different from |v:ctype| when messages are desired
        in a different language than what is used for character
        encoding.  See |multi-lang|.

                        *v:lc_time* *lc_time-variable*
v:lc_time    The current locale setting for time messages of the runtime
        environment.  This allows Vim scripts to be aware of the
        current language.  Technical: it's the value of LC_TIME.
        This variable can not be set directly, use the |:language|
        command.  See |multi-lang|.

                        *v:ctype* *ctype-variable*
v:ctype        The current locale setting for characters of the runtime
        environment.  This allows Vim scripts to be aware of the
        current locale encoding.  Technical: it's the value of
        LC_CTYPE.
        This variable can not be set directly, use the |:language|
        command.
        Normally it's equal to 'encoding', but not always...
        See |multi-lang|.

                        *v:lnum* *lnum-variable*
v:lnum        Line number for the 'foldexpr' and 'indentexpr' expressions.
        Only valid while one of these expressions is being evaluated.
        Read-only. |fold-expr| 'indentexpr'

                    *v:servername* *servername-variable*
v:servername    The resulting registered |x11-clientserver| name if any.

                    *v:shell_error* *shell_error-variable*
v:shell_error    Result of the last shell command.  When non-zero, the last
        shell command had an error.  When zero, there was no problem.
        This only works when the shell returns the error code to Vim.
        The value -1 is often used when the command could not be
        executed.  Read-only.
        Example: >
    :!mv foo bar
    :if v:shell_error
    :  echo 'could not rename "foo" to "bar"!'
    :endif
<        "shell_error" also works, for backwards compatibility.

                    *v:statusmsg* *statusmsg-variable*
v:statusmsg    Last given status message.  It's allowed to set this variable.

                *v:termresponse* *termresponse-variable*
v:termresponse    The escape sequence returned by the terminal for the |t_RV|
        termcap entry.  It is set when Vim receives an escape sequence
        that starts with ESC [ or CSI and ends in a 'c', with only
        digits, ';' and '.' in between.
        When this option is set, the TermResponse autocommand event is
        fired, so that you can react to the response from the
        terminal.
        The response from a new xterm is: "<Esc>[ Pp ; Pv ; Pc c".  Pp
        is the terminal type: 0 for vt100 and 1 for vt220.  Pv is the
        patch level (since this was introduced in patch 95, it's
        always 95 or bigger).  Pc is always zero.
        {only when compiled with |+termresponse| feature}

                *v:this_session* *this_session-variable*
v:this_session    Full filename of the last loaded or saved session file.  See
        |:mksession|.  It is allowed to set this variable.  When no
        session file has been saved, this variable is empty.
        "this_session" also works, for backwards compatibility.

                    *v:version* *version-variable*
v:version    Version number of Vim: Major version number times 100 plus
        minor version number.  Version 5.0 is 500.  Version 5.1 (5.01)
        is 501.  Read-only.  "version" also works, for backwards
        compatibility.

                    *v:warningmsg* *warningmsg-variable*
v:warningmsg    Last given warning message.  It's allowed to set this variable.

==============================================================================
4. Builtin Functions                    *functions*

See |function-list| for a list grouped by what the function is used for.

(Use CTRL-] on the function name to jump to the full explanation)

USAGE                RESULT    DESCRIPTION    ~

append( {lnum}, {string})    Number  append {string} below line {lnum}
argc()                Number    number of files in the argument list
argidx()            Number  current index in the argument list
argv( {nr})            String    {nr} entry of the argument list
browse( {save}, {title}, {initdir}, {default})
                String    put up a file requester
bufexists( {expr})        Number    TRUE if buffer {expr} exists
buflisted( {expr})        Number  TRUE if buffer {expr} is listed
bufloaded( {expr})        Number  TRUE if buffer {expr} is loaded
bufname( {expr})        String    Name of the buffer {expr}
bufnr( {expr})            Number    Number of the buffer {expr}
bufwinnr( {expr})        Number    window number of buffer {expr}
byte2line( {byte})        Number    line number at byte count {byte}
char2nr( {expr})        Number    ASCII value of first char in {expr}
cindent( {lnum})        Number  C indent for line {lnum}
col( {expr})            Number    column nr of cursor or mark
confirm( {msg}, {choices} [, {default} [, {type}]])
                Number    number of choice picked by user
cscope_connection( [{num} , {dbpath} [, {prepend}]])
                Number    checks existence of cscope connection
delete( {fname})        Number    delete file {fname}
did_filetype()            Number    TRUE if FileType autocommand event used
escape( {string}, {chars})    String    escape {chars} in {string} with '\'
eventhandler( )            Number  TRUE if inside an event handler
executable( {expr})        Number    1 if executable {expr} exists
exists( {var})            Number    TRUE if {var} exists
expand( {expr})            String    expand special keywords in {expr}
filereadable( {file})        Number    TRUE if {file} is a readable file
fnamemodify( {fname}, {mods})    String    modify file name
foldclosed( {lnum})        Number  >0 if fold at {lnum} is closed
foldlevel( {lnum})        Number    fold level at {lnum}
foldtext( )            String  line displayed for closed fold
foreground( )            Number    bring the Vim window to the foreground
getchar( [expr])        Number  get one character from the user
getcharmod( )            Number  modifiers for the last typed character
getbufvar( {expr}, {varname})        variable {varname} in buffer {expr}
getcwd()            String    the current working directory
getftime( {fname})        Number    last modification time of file
getfsize( {fname})        Number    size in bytes of file
getline( {lnum})        String    line {lnum} from current buffer
getwinposx()            Number    X coord in pixels of GUI vim window
getwinposy()            Number    Y coord in pixels of GUI vim window
getwinvar( {nr}, {varname}        variable {varname} in window {nr}
glob( {expr}])            String    expand file wildcards in {expr}
globpath( {path}, {expr})    String    do glob({expr}) for all dirs in {path}
has( {feature})            Number    TRUE if feature {feature} supported
hasmapto( {what} [, {mode}])    Number    TRUE if mapping to {what} exists
histadd( {history},{item})    String    add an item to a history
histdel( {history} [, {item}])    String    remove an item from a history
histget( {history} [, {index}])    String    get the item {index} from a history
histnr( {history})        Number    highest index of a history
hlexists( {name})        Number    TRUE if highlight group {name} exists
hlID( {name})            Number    syntax ID of highlight group {name}
hostname()            String    name of the machine vim is running on
indent( {lnum})            Number  indent of line {lnum}
input( {prompt} [, {text}])    String    get input from the user
inputdialog( {prompt} [, {text}]) String  like input() but in a GUI dialog
inputsecret( {prompt} [, {text}]) String  like input() but hiding the text
isdirectory( {directory})    Number    TRUE if {directory} is a directory
libcall( {lib}, {func}, {arg})    String  call {func} in library {lib} with {arg}
libcallnr( {lib}, {func}, {arg})  Number  idem, but return a Number
line( {expr})            Number    line nr of cursor, last line or mark
line2byte( {lnum})        Number    byte count of line {lnum}
lispindent( {lnum})        Number  Lisp indent for line {lnum}
localtime()            Number    current time
maparg( {name}[, {mode}])    String    rhs of mapping {name} in mode {mode}
mapcheck( {name}[, {mode}])    String    check for mappings matching {name}
match( {expr}, {pat}[, {start}])
                Number    position where {pat} matches in {expr}
matchend( {expr}, {pat}[, {start})
                Number    position where {pat} ends in {expr}
matchstr( {expr}, {pat}[, {start}])
                String    match of {pat} in {expr}
mode()                String  current editing mode
nextnonblank( {lnum})        Number    line nr of non-blank line >= {lnum}
nr2char( {expr})        String    single char with ASCII value {expr}
prevnonblank( {lnum})        Number    line nr of non-blank line <= {lnum}
remote_expr( {server}, {string} [, {idvar}])
                String    send expression
remote_foreground( {server})    Number    bring Vim server to the foreground
remote_peek( {serverid} [, {retvar}])
                Number    check for reply string
remote_read( {serverid})    String    read reply string
remote_send( {server}, {string} [, {idvar}])
                String    send key sequence
rename( {from}, {to})        Number  rename (move) file from {from} to {to}
resolve( {filename})        String  get filename a shortcut points to
search( {pattern} [, {flags}])    Number  search for {pattern}
searchpair( {start}, {middle}, {end} [, {flags} [, {skip}]])
                Number  search for other end of start/end pair
server2client( {serverid}, {string})
                Number    send reply string
serverlist()            String    get a list of available servers
setbufvar( {expr}, {varname}, {val})    set {varname} in buffer {expr} to {val}
setline( {lnum}, {line})    Number    set line {lnum} to {line}
setwinvar( {nr}, {varname}, {val})    set {varname} in window {nr} to {val}
strftime( {format}[, {time}])    String    time in specified format
stridx( {haystack}, {needle})    Number    first index of {needle} in {haystack}
strlen( {expr})            Number    length of the String {expr}
strpart( {src}, {start}[, {len}])
                String    {len} characters of {src} at {start}
strridx( {haystack}, {needle})    Number    last index of {needle} in {haystack}
strtrans( {expr})        String    translate string to make it printable
submatch( {nr})            String  specific match in ":substitute"
substitute( {expr}, {pat}, {sub}, {flags})
                String    all {pat} in {expr} replaced with {sub}
synID( {line}, {col}, {trans})    Number    syntax ID at {line} and {col}
synIDattr( {synID}, {what} [, {mode}])
                String    attribute {what} of syntax ID {synID}
synIDtrans( {synID})        Number    translated syntax ID of {synID}
system( {expr})            String    output of shell command {expr}
tempname()            String    name for a temporary file
tolower( {expr})        String    the String {expr} switched to lowercase
toupper( {expr})        String    the String {expr} switched to uppercase
type( {name})            Number    type of variable {name}
virtcol( {expr})        Number    screen column of cursor or mark
visualmode()            String    last visual mode used
winbufnr( {nr})            Number    buffer number of window {nr}
wincol()            Number    window column of the cursor
winheight( {nr})        Number    height of window {nr}
winline()            Number    window line of the cursor
winnr()                Number    number of current window
winwidth( {nr})            Number    width of window {nr}

append({lnum}, {string})                *append()*
        Append the text {string} after line {lnum} in the current
        buffer.  {lnum} can be zero, to insert a line before the first
        one.  Returns 1 for failure ({lnum} out of range) or 0 for
        success.

                            *argc()*
argc()        The result is the number of files in the argument list of the
        current window.  See |arglist|.

                            *argidx()*
argidx()    The result is the current index in the argument list.  0 is
        the first file.  argc() - 1 is the last one.  See |arglist|.

                            *argv()*
argv({nr})    The result is the {nr}th file in the argument list of the
        current window.  See |arglist|.  "argv(0)" is the first one.
        Example: >
    :let i = 0
    :while i < argc()
    :  let f = substitute(argv(i), '\([. ]\)', '\\&', 'g')
    :  exe 'amenu Arg.' . f . ' :e ' . f . '<CR>'
    :  let i = i + 1
    :endwhile
<
                            *browse()*
browse({save}, {title}, {initdir}, {default})
        Put up a file requester.  This only works when "has("browse")"
        returns non-zero (only in some GUI versions).
        The input fields are:
            {save}    when non-zero, select file to write
            {title}    title for the requester
            {initdir}    directory to start browsing in
            {default}    default file name
        When the "Cancel" button is hit, something went wrong, or
        browsing is not possible, an empty string is returned.

bufexists({expr})                    *bufexists()*
        The result is a Number, which is non-zero if a buffer called
        {expr} exists.
        If the {expr} argument is a string it must match a buffer name
        exactly.
        If the {expr} argument is a number buffer numbers are used.
        Unlisted buffers will be found.
        Note that help files are listed by their short name in the
        output of |:buffers|, but bufexists() requires using their
        long name to be able to find them.
        Use "bufexists(0)" to test for the existence of an alternate
        file name.
                            *buffer_exists()*
        Obsolete name: buffer_exists().

buflisted({expr})                    *buflisted()*
        The result is a Number, which is non-zero if a buffer called
        {expr} exists and is listed (has the 'buflisted' option set).
        The {expr} argument is used like with bufexists().

bufloaded({expr})                    *bufloaded()*
        The result is a Number, which is non-zero if a buffer called
        {expr} exists and is loaded (shown in a window or hidden).
        The {expr} argument is used like with bufexists().

bufname({expr})                        *bufname()*
        The result is the name of a buffer, as it is displayed by the
        ":ls" command.
        If {expr} is a Number, that buffer number's name is given.
        Number zero is the alternate buffer for the current window.
        If {expr} is a String, it is used as a regexp pattern to match
        with the buffer names.  This is always done like 'magic' is
        set and 'cpoptions' is empty.  When there is more than one
        match an empty string is returned.  "" or "%" can be used for
        the current buffer, "#" for the alternate buffer.
        If the {expr} is a String, but you want to use it as a buffer
        number, force it to be a Number by adding zero to it: >
            :echo bufname("3" + 0)
<        If the buffer doesn't exist, or doesn't have a name, an empty
        string is returned. >
    bufname("#")        alternate buffer name
    bufname(3)        name of buffer 3
    bufname("%")        name of current buffer
    bufname("file2")    name of buffer where "file2" matches.
<                            *buffer_name()*
        Obsolete name: buffer_name().

                            *bufnr()*
bufnr({expr})    The result is the number of a buffer, as it is displayed by
        the ":ls" command.  For the use of {expr}, see |bufname()|
        above.  If the buffer doesn't exist, -1 is returned.
        bufnr("$") is the last buffer: >
    :let last_buffer = bufnr("$")
<        The result is a Number, which is the highest buffer number
        of existing buffers.  Note that not all buffers with a smaller
        number necessarily exist, because ":bwipeout" may have removed
        them.  Use bufexists() to test for the existence of a buffer.
                            *buffer_number()*
        Obsolete name: buffer_number().
                            *last_buffer_nr()*
        Obsolete name for bufnr("$"): last_buffer_nr().

bufwinnr({expr})                    *bufwinnr()*
        The result is a Number, which is the number of the first
        window associated with buffer {expr}.  For the use of {expr},
        see |bufname()| above.  If buffer {expr} doesn't exist or
        there is no such window, -1 is returned.  Example: >
    echo "A window containing buffer 1 is " . (bufwinnr(1))
<
byte2line({byte})                    *byte2line()*
        Return the line number that contains the character at byte
        count {byte} in the current buffer.  This includes the
        end-of-line character, depending on the 'fileformat' option
        for the current buffer.  The first character has byte count
        one.
        Also see |line2byte()|, |go| and |:goto|.
        {not available when compiled without the |+byte_offset|
        feature}

char2nr({expr})                        *char2nr()*
        Return ASCII value of the first char in {expr}.  Examples: >
            char2nr(" ")        returns 32
            char2nr("ABC")        returns 65
<
cindent({lnum})                        *cindent()*
        Get the amount of indent for line {lnum} according the C
        indenting rules, as with 'cindent'.
        The indent is counted in spaces, the value of 'tabstop' is
        relevant.  {lnum} is used just like in |getline()|.
        When {lnum} is invalid or Vim was not compiled the |+cindent|
        feature, -1 is returned.

                            *col()*
col({expr})    The result is a Number, which is the column of the file
        position given with {expr}.  The accepted positions are:
            .        the cursor position
            $        the end of the cursor line (the result is the
                number of characters in the cursor line plus one)
            'x        position of mark x (if the mark is not set, 0 is
                returned)
        Note that only marks in the current file can be used.
        Examples: >
            col(".")        column of cursor
            col("$")        length of cursor line plus one
            col("'t")        column of mark t
            col("'" . markname)    column of mark markname
<        The first column is 1.  0 is returned for an error.

                            *confirm()*
confirm({msg}, {choices} [, {default} [, {type}]])
        Confirm() offers the user a dialog, from which a choice can be
        made.  It returns the number of the choice.  For the first
        choice this is 1.
        Note: confirm() is only supported when compiled with dialog
        support, see |+dialog_con| and |+dialog_gui|.
        {msg} is displayed in a |dialog| with {choices} as the
        alternatives.
        {msg} is a String, use '\n' to include a newline.  Only on
        some systems the string is wrapped when it doesn't fit.
        {choices} is a String, with the individual choices separated
        by '\n', e.g. >
            confirm("Save changes?", "&Yes\n&No\n&Cancel")
<        The letter after the '&' is the shortcut key for that choice.
        Thus you can type 'c' to select "Cancel".  The shorcut does
        not need to be the first letter: >
            confirm("file has been modified", "&Save\nSave &All")
<        For the console, the first letter of each choice is used as
        the default shortcut key.
        The optional {default} argument is the number of the choice
        that is made if the user hits <CR>.  Use 1 to make the first
        choice the default one.  Use 0 to not set a default.  If
        {default} is omitted, 0 is used.
        The optional {type} argument gives the type of dialog.  This
        is only used for the icon of the Win32 GUI.  It can be one of
        these values: "Error", "Question", "Info", "Warning" or
        "Generic".  Only the first character is relevant.  When {type}
        is omitted, "Generic" is used.
        If the user aborts the dialog by pressing <Esc>, CTRL-C,
        or another valid interrupt key, confirm() returns 0.

        An example: >
   :let choice = confirm("What do you want?", "&Apples\n&Oranges\n&Bananas", 2)
   :if choice == 0
   :    echo "make up your mind!"
   :elseif choice == 3
   :    echo "tasteful"
   :else
   :    echo "I prefer bananas myself."
   :endif
<        In a GUI dialog, buttons are used.  The layout of the buttons
        depends on the 'v' flag in 'guioptions'.  If it is included,
        the buttons are always put vertically.  Otherwise,  confirm()
        tries to put the buttons in one horizontal line.  If they
        don't fit, a vertical layout is used anyway.  For some systems
        the horizontal layout is always used.

                            *cscope_connection()*
cscope_connection([{num} , {dbpath} [, {prepend}]])
        Checks for the existence of a |cscope| connection.  If no
        parameters are specified, then the function returns:
            0, if cscope was not available (not compiled in), or
               if there are no cscope connections;
            1, if there is at least one cscope connection.

        If parameters are specified, then the value of {num}
        determines how existence of a cscope connection is checked:

        {num}    Description of existence check
        -----    ------------------------------
        0    Same as no parameters (e.g., "cscope_connection()").
        1    Ignore {prepend}, and use partial string matches for
            {dbpath}.
        2    Ignore {prepend}, and use exact string matches for
            {dbpath}.
        3    Use {prepend}, use partial string matches for both
            {dbpath} and {prepend}.
        4    Use {prepend}, use exact string matches for both
            {dbpath} and {prepend}.

        Note: All string comparisons are case sensitive!

        Examples.  Suppose we had the following (from ":cs show"): >

  # pid    database name            prepend path
  0 27664  cscope.out                /usr/local
<
        Invokation                    Return Val ~
        ----------                    ---------- >
        cscope_connection()                    1
        cscope_connection(1, "out")                1
        cscope_connection(2, "out")                0
        cscope_connection(3, "out")                0
        cscope_connection(3, "out", "local")            1
        cscope_connection(4, "out")                0
        cscope_connection(4, "out", "local")            0
        cscope_connection(4, "cscope.out", "/usr/local")    1
<
                            *delete()*
delete({fname})    Deletes the file by the name {fname}.  The result is a Number,
        which is 0 if the file was deleted successfully, and non-zero
        when the deletion failed.

                            *did_filetype()*
did_filetype()    Returns non-zero when autocommands are being executed and the
        FileType event has been triggered at least once.  Can be used
        to avoid triggering the FileType event again in the scripts
        that detect the file type. |FileType|
        When editing another file, the counter is reset, thus this
        really checks if the FileType event has been triggered for the
        current buffer.  This allows an autocommand that starts
        editing another buffer to set 'filetype' and load a sytnax
        file.

escape({string}, {chars})                *escape()*
        Escape the characters in {chars} that occur in {string} with a
        backslash.  Example: >
            :echo escape('c:\program files\vim', ' \')
<        results in: >
            c:\\program\ files\\vim
<
eventhandler()                        *eventhandler()*
        Returns 1 when inside an event handler.  This means
        interactive commands cannot be used.  Otherwise zero is
        returned.

executable({expr})                    *executable()*
        This function checks if an executable with the name {expr}
        exists.  {expr} must be the name of the program without any
        arguments.  executable() uses the normal $PATH.
        The result is a Number:
            1    exists
            0    does not exist
            -1    not implemented on this system

                            *exists()*
exists({expr})    The result is a Number, which is non-zero if {var} is defined,
        zero otherwise.  The {expr} argument is a string, which
        contains one of these:
            &option-name    Vim option
            $ENVNAME    environment variable (could also be
                    done by comparing with an empty
                    string)
            *funcname    built-in function (see |functions|)
                    or user defined function (see
                    |user-functions|).
            varname        internal variable (see
                    |internal-variables|).
            :cmdname    Ex command, both built-in and user
                    commands |:command|
                    returns:
                    1  for match with start of a command
                    2  full match with a command
                    3  matches several user commands
            #event        autocommand defined for this event
            #event#pattern    autocommand defined for this event and
                    pattern (the pattern is taken
                    literally and compared to the
                    autocommand patterns character by
                    character)

        Examples: >
            exists("&shortname")
            exists("$HOSTNAME")
            exists("*strftime")
            exists("bufcount")
            exists(":Make")
            exists("#CursorHold");
            exists("#BufReadPre#*.gz")
<        There must be no space between the symbol (&/$/*/#) and the
        name.
        Note that the argument must be a string, not the name of the
        variable itself!  For example: >
            exists(bufcount)
<        This doesn't check for existence of the "bufcount" variable,
        but gets the contents of "bufcount", and checks if that
        exists.

expand({expr} [, {flag}])                *expand()*
        Expand wildcards and the following special keywords in {expr}.
        The result is a String.

        When there are several matches, they are separated by <NL>
        characters.  [Note: in version 5.0 a space was used, which
        caused problems when a file name contains a space]

        If the expansion fails, the result is an empty string.  A name
        for a non-existing file is not included.

        When {expr} starts with '%', '#' or '<', the expansion is done
        like for the |cmdline-special| variables with their associated
        modifiers.  Here is a short overview:

            %        current file name
            #        alternate file name
            #n        alternate file name n
            <cfile>        file name under the cursor
            <afile>        autocmd file name
            <abuf>        autocmd buffer number
            <amatch>    autocmd matched name
            <sfile>        sourced script file name
            <cword>        word under the cursor
            <cWORD>        WORD under the cursor
            <client>    The {serverid} of the las
        Modifiers:
            :p        expand to full path
            :h        head (last path component removed)
            :t        tail (last path component only)
            :r        root (one extension removed)
            :e        extension only

        Example: >
            :let &tags = expand("%:p:h") . "/tags"
<        Note that when expanding a string that starts with '%', '#' or
        '<', any following text is ignored.  This does NOT work: >
            :let doesntwork = expand("%:h.bak")
<        Use this: >
            :let doeswork = expand("%:h") . ".bak"
<        Also note that expanding "<cfile>" and others only returns the
        referenced file name without further expansion.  If "<cfile>"
        is "~/.cshrc", you need to do another expand() to have the
        "~/" expanded into the path of the home directory: >
            :echo expand(expand("<cfile>"))
<
        There cannot be white space between the variables and the
        following modifier.  The |fnamemodify()| function can be used
        to modify normal file names.

        When using '%' or '#', and the current or alternate file name
        is not defined, an empty string is used.  Using "%:p" in a
        buffer with no name, results in the current directory, with a
        '/' added.

        When {expr} does not start with '%', '#' or '<', it is
        expanded like a file name is expanded on the command line.
        'suffixes' and 'wildignore' are used, unless the optional
        {flag} argument is given and it is non-zero.

        Expand() can also be used to expand variables and environment
        variables that are only known in a shell.  But this can be
        slow, because a shell must be started.  See |expr-env-expand|.

        See |glob()| for finding existing files.  See |system()| for
        getting the raw output of an external command.

expandpath({expr}, {pathlist})                *expandpath()*
        Find all matches for {expr} in each element of {pathlist}.
        Each match is followed by a <NL>.  Example: >
            let list = expandpath("colors/*.vim", &runtimepath)
<        This gets a list of the color scheme files in 'runtimepath'.
        {pathlist} must be a comma separated list of paths.
        When there are no matches an empty string is returned.


filereadable({file})                    *filereadable()*
        The result is a Number, which is TRUE when a file with the
        name {file} exists, and can be read.  If {file} doesn't exist,
        or is a directory, the result is FALSE.  {file} is any
        expression, which is used as a String.
                            *file_readable()*
        Obsolete name: file_readable().

filewritable({file})                    *filewritable()*
        The result is a Number, which is 1 when a file with the
        name {file} exists, and can be written.  If {file} doesn't
        exist, or is not writable, the result is 0.  If (file) is a
        directory, and we can write to it, the result is 2.

fnamemodify({fname}, {mods})                *fnamemodify()*
        Modify file name {fname} according to {mods}.  {mods} is a
        string of characters like it is used for file names on the
        command line.  See |filename-modifiers|.
        Example: >
            :echo fnamemodify("main.c", ":p:h")
<        results in: >
            /home/mool/vim/vim/src
<        Note: Environment variables and "~" don't work in {fname}, use
        |expand()| first then.

foldclosed({lnum})                    *foldclosed()*
        The result is a Number.  If the line {lnum} is in a closed
        fold, the result is the number of the first line in that fold.
        If the line {lnum} is not in a closed fold, -1 is returned.

foldclosedend({lnum})                    *foldclosedend()*
        The result is a Number.  If the line {lnum} is in a closed
        fold, the result is the number of the last line in that fold.
        If the line {lnum} is not in a closed fold, -1 is returned.

foldlevel({lnum})                    *foldlevel()*
        The result is a Number, which is the foldlevel of line {lnum}
        in the current buffer.  For nested folds the deepest level is
        returned.  If there is no fold at line {lnum}, zero is
        returned.  It doesn't matter if the folds are open or closed.
        When used while updating folds (from 'foldexpr') -1 is
        returned for lines where folds are still to be updated and the
        foldlevel is unknown.

                            *foldtext()*
foldtext()    Returns a String, to be displayed for a closed fold.  This is
        the default function used for the 'foldtext' option and should
        only be called from evaluating 'foldtext'.  It uses the
        |v:foldstart|, |v:foldend| and |v:folddashes| variables.
        The returned string looks like this: >
            +-- 45 lines: abcdef
<        The number of dashes depends on the foldlevel.  The "45" is
        the number of lines in the fold.  "abcdef" is the text in the
        first non-blank line of the fold.  Leading white space, "//"
        or "/*" and the text from the 'foldmarker' and 'commentstring'
        options is removed.
        {not available when compiled without the |+folding| feature}

                            *foreground()*
foreground()    Move the Vim window to the foreground.  Useful when sent from
        a client to a Vim server. |remote_send()|
        On Win32 systems this might not work, the OS does not always
        allow a window to bring itself to the foreground.  Use
        |remote_foreground()| instead.
        {only in the Win32, Athena, Motif and GTK GUI versions and the
        Win32 console version}

getchar([expr])                        *getchar()*
        Get a single character from the user.  If it is an 8-bit
        character, the result is a number.  Otherwise a String is
        returned with the encoded character.
        If [expr] is omitted, wait until a character is available.
        If [expr] is 0, only get a character when one is available.
        If [expr] is 1, only check if a character is available, it is
                not consumed.  If a normal character is
                available, it is returned, otherwise a
                non-zero value is returned.
        If a character available, it is returned as a Number.  Use
        nr2char() to convert it to a String.
        The returned value is negative for special keys.
        The returned value is zero if no character is available.
        There is no prompt, you will somehow have to make clear to the
        user that a character has to be typed.
        There is no mapping for the character.
        Key codes are replaced, thus when the user presses the <Del>
        key you get the code for the <Del> key, not the raw character
        sequence.  Examples: >
            getchar() == "\<Del>"
            getchar() == "\<S-Left>"
<        This example redefines "f" to ignore case: >
            :nmap f :call FindChar()<CR>
            :function FindChar()
            :  let c = nr2char(getchar())
            :  while col('.') < col('$') - 1
            :    normal l
            :    if getline('.')[col('.') - 1] ==? c
            :      break
            :    endif
            :  endwhile
            :endfunction

getcharmod()                        *getcharmod()*
        The result is a Number which is the state of the modifiers for
        the last obtained character with getchar() or in another way.
        These values are added together:
            2    shift
            4    control
            8    alt (meta)
            16    mouse double click
            32    mouse triple click
            64    mouse quadruple click
            128    Macintosh only: command

getbufvar({expr}, {varname})                *getbufvar()*
        The result is the value of option or local buffer variable
        {varname} in buffer {expr}.
        This also works for a global or local window option, but it
        doesn't work for a global or local window variable.
        For the use of {expr}, see |bufname()| above.
        Note that the name without "b:" must be used.
        Examples: >
            :let bufmodified = getbufvar(1, "&mod")
            :echo "todo myvar = " . getbufvar("todo", "myvar")
<
                            *getcwd()*
getcwd()    The result is a String, which is the name of the current
        working directory.

getftime({fname})                    *getftime()*
        The result is a Number, which is the last modification time of
        the given file {fname}.  The value is measured as seconds
        since 1st Jan 1970, and may be passed to strftime().  See also
        |localtime()| and |strftime()|.
        If the file {fname} can't be found -1 is returned.

getfsize({fname})                    *getfsize()*
        The result is a Number, which is the size in bytes of the
        given file {fname}.
        If {fname} is a directory, 0 is returned.
        If the file {fname} can't be found, -1 is returned.

                            *getline()*
getline({lnum}) The result is a String, which is line {lnum} from the current
        buffer.  Example: >
            getline(1)
<        When {lnum} is a String that doesn't start with a
        digit, line() is called to translate the String into a Number.
        To get the line under the cursor: >
            getline(".")
<        When {lnum} is smaller than 1 or bigger than the number of
        lines in the buffer, an empty string is returned.

                            *getwinposx()*
getwinposx()    The result is a Number, which is the X coordinate in pixels of
        the left hand side of the GUI vim window.  The result will be
        -1 if the information is not available.

                            *getwinposy()*
getwinposy()    The result is a Number, which is the Y coordinate in pixels of
        the top of the GUI vim window.  The result will be -1 if the
        information is not available.

getwinvar({nr}, {varname})                *getwinvar()*
        The result is the value of option or local window variable
        {varname} in window {nr}.
        This also works for a global or local buffer option, but it
        doesn't work for a global or local buffer variable.
        Note that the name without "w:" must be used.
        Examples: >
            :let list_is_on = getwinvar(2, '&list')
            :echo "myvar = " . getwinvar(1, 'myvar')
<
                            *glob()*
glob({expr})    Expand the file wildcards in {expr}.  The result is a String.
        When there are several matches, they are separated by <NL>
        characters.
        If the expansion fails, the result is an empty string.
        A name for a non-existing file is not included.

        For most systems backticks can be used to get files names from
        any external command.  Example: >
            :let tagfiles = glob("`find . -name tags -print`")
            :let &tags = substitute(tagfiles, "\n", ",", "g")
<        The result of the program inside the backticks should be one
        item per line.  Spaces inside an item are allowed.

        See |expand()| for expanding special Vim variables.  See
        |system()| for getting the raw output of an external command.

globpath({path}, {expr})                *globpath()*
        Perform glob() on all directories in {path} and concatenate
        the results.  Example: >
            :echo globpath(&rtp, "syntax/c.vim")
<        {path} is a comma-separated list of directory names.  Each
        directory name is prepended to {expr} and expanded like with
        glob().  A path separator is inserted when needed.
        If the expansion fails for one of the directories, there is no
        error message.

                            *has()*
has({feature})    The result is a Number, which is 1 if the feature {feature} is
        supported, zero otherwise.  The {feature} argument is a
        string.  See |feature-list| below.

hasmapto({what} [, {mode}])                *hasmapto()*
        The result is a Number, which is 1 if there is a mapping that
        contains {what} in the rhs (what it is mapped to) and this
        mapping exists in one of the modes indicated by {mode}.
        Both the global mappings and the mappings local to the current
        buffer are checked for a match.
        If no matching mapping is found 0 is returned.
        The following characters are recognized in {mode}:
            n    Normal mode
            v    Visual mode
            o    Operator-pending mode
            i    Insert mode
            l    Language-Argument ("r", "f", "t", etc.)
            c    Command-line mode
        When {mode} is omitted, "nvo" is used.

        This function is useful to check if a mapping already exists
        to a function in a Vim script.  Example: >
            :if !hasmapto('\ABCdoit')
            :   map <Leader>d \ABCdoit
            :endif
<        This installs the mapping to "\ABCdoit" only if there isn't
        already a mapping to "\ABCdoit".

histadd({history}, {item})                *histadd()*
        Add the String {item} to the history {history} which can be
        one of:                    *hist-names*
            "cmd"     or ":"      command line history
            "search" or "/"   search pattern history
            "expr"   or "="   typed expression history
            "input"  or "@"      input line history
        If {item} does already exist in the history, it will be
        shifted to become the newest entry.
        The result is a Number: 1 if the operation was successful,
        otherwise 0 is returned.

        Example: >
            :call histadd("input", strftime("%Y %b %d"))
            :let date=input("Enter date: ")
<
histdel({history} [, {item}])                *histdel()*
        Clear {history}, ie. delete all its entries.  See |hist-names|
        for the possible values of {history}.

        If the parameter {item} is given as String, this is seen
        as regular expression.  All entries matching that expression
        will be removed from the history (if there are any).
        Upper/lowercase must match, unless "\c" is used |/\c|"
        If {item} is a Number, it will be interpreted as index, see
        |:history-indexing|.  The respective entry will be removed
        if it exists.

        The result is a Number: 1 for a successful operation,
        otherwise 0 is returned.

        Examples:
        Clear expression register history: >
            :call histdel("expr")
<
        Remove all entries starting with "*" from the search history: >
            :call histdel("/", '^\*')
<
        The following three are equivalent: >
            :call histdel("search", histnr("search"))
            :call histdel("search", -1)
            :call histdel("search", '^'.histget("search", -1).'$')
<
        To delete the last search pattern and use the last-but-one for
        the "n" command and 'hlsearch': >
            :call histdel("search", -1)
            :let @/ = histget("search", -1)

histget({history} [, {index}])                *histget()*
        The result is a String, the entry with Number {index} from
        {history}.  See |hist-names| for the possible values of
        {history}, and |:history-indexing| for {index}.  If there is
        no such entry, an empty String is returned.  When {index} is
        omitted, the most recent item from the history is used.

        Examples:
        Redo the second last search from history. >
            :execute '/' . histget("search", -2)

<        Define an Ex command ":H {num}" that supports re-execution of
        the {num}th entry from the output of |:history|. >
            :command -nargs=1 H execute histget("cmd", 0+<args>)
<
histnr({history})                    *histnr()*
        The result is the Number of the current entry in {history}.
        See |hist-names| for the possible values of {history}.
        If an error occurred, -1 is returned.

        Example: >
            :let inp_index = histnr("expr")
<
hlexists({name})                    *hlexists()*
        The result is a Number, which is non-zero if a highlight group
        called {name} exists.  This is when the group has been
        defined in some way.  Not necessarily when highlighting has
        been defined for it, it may also have been used for a syntax
        item.
                            *highlight_exists()*
        Obsolete name: highlight_exists().

                            *hlID()*
hlID({name})    The result is a Number, which is the ID of the highlight group
        with name {name}.  When the highlight group doesn't exist,
        zero is returned.
        This can be used to retrieve information about the highlight
        group.  For example, to get the background color of the
        "Comment" group: >
    :echo synIDattr(synIDtrans(hlID("Comment")), "bg")
<                            *highlightID()*
        Obsolete name: highlightID().

hostname()                        *hostname()*
        The result is a String, which is the name of the machine on
        which Vim is currently running. Machine names greater than
        256 characters long are truncated.

iconv({expr}, {from}, {to})                *iconv()*
        The result is a String, which is the text {expr} converted
        from encoding {from} to encoding {to}.
        When the conversion fails an empty string is returned.
        The encoding names are whatever the iconv() library function
        can accept, see ":!man 3 iconv".
        Most conversions require Vim to be compiled with the |+iconv|
        feature.  Otherwise only UTF-8 to latin1 conversion and back
        can be done.
        This can be used to display messages with special characters,
        no matter what 'encoding' is set to.  Write the message in
        UTF-8 and use: >
            echo iconv(utf8_str, "utf-8", &enc)
<        Note that Vim uses UTF-8 for all Unicode encodings, conversion
        from/to UCS-2 is automatically changed to use UTF-8.  You
        cannot use UCS-2 in a string anyway, because of the NUL bytes.
        {only available when compiled with the +multi_byte feature}

                            *indent()*
indent({lnum})    The result is a Number, which is indent of line {lnum} in the
        current buffer.  The indent is counted in spaces, the value
        of 'tabstop' is relevant.  {lnum} is used just like in
        |getline()|.
        When {lnum} is invalid -1 is returned.

input({prompt} [, {text}])                *input()*
        The result is a String, which is whatever the user typed on
        the command-line.  The parameter is either a prompt string, or
        a blank string (for no prompt).  A '\n' can be used in the
        prompt to start a new line.  The highlighting set with
        |:echohl| is used for the prompt.  The input is entered just
        like a command-line, with the same editing commands and
        mappings.  There is a separate history for lines typed for
        input().
        If the optional {text} is present, this is used for the
        default reply, as if the user typed this.
        NOTE: This must not be used in a startup file, for the
        versions that only run in GUI mode (e.g., the Win32 GUI).

        Example: >
            :if input("Coffee or beer? ") == "beer"
            :  echo "Cheers!"
            :endif
<        Example with default text: >
            :let color = input("Color? ", "white")

inputdialog({prompt} [, {text})                *inputdialog()*
        Like input(), but when the GUI is running and text dialogs are
        supported, a dialog window pops up to input the text.
        Example: >
            :let n = inputdialog("value for shiftwidth", &sw)
            :if n != ""
            :  let &sw = n
            :endif
<        Hitting <Enter> works like pressing the OK button.  Hitting
        <Esc> works like pressing the Cancel button.

inputsecret({prompt} [, {text}])            *inputsecret()*
        This function acts much like the |input()| function with but
        two exceptions:
        a) the user's response will be displayed as a sequence of
        asterisks ("*") thereby keeping the entry secret, and
        b) the user's response will not be recorded on the input
        |history| stack.
        The result is a String, which is whatever the user actually
        typed on the command-line in response to the issued prompt.

isdirectory({directory})                *isdirectory()*
        The result is a Number, which is non-zero when a directory
        with the name {directory} exists.  If {directory} doesn't
        exist, or isn't a directory, the result is FALSE.  {directory}
        is any expression, which is used as a String.

                        *libcall()* *E364* *E368*
libcall({libname}, {funcname}, {argument})
        Call function {funcname} in the run-time library {libname}
        with single argument {argument}.
        This is useful to call functions in a library that you
        especially made to be used with Vim.  Since only one argument
        is possible, calling standard library functions is rather
        limited.
        The result is the String returned by the function.  If the
        function returns NULL, this will appear as an empty string ""
        to Vim.
        If the function returns a number, use libcallnr()!
        If {argument} is a number, it is passed to the function as an
        int; if {param} is a string, it is passed as a null-terminated
        string.

        libcall() allows you to write your own 'plug-in' extensions to
        Vim without having to recompile the program.  It is NOT a
        means to call system functions!  If you try to do so Vim will
        very probably crash.

        For Win32, the functions you write must be placed in a DLL
        and use the normal C calling convention (NOT Pascal which is
        used in Windows System DLLs).  The function must take exactly
        one parameter, either a character pointer or a long integer,
        and must return a character pointer or NULL.  The character
        pointer returned must point to memory that will remain valid
        after the function has returned (e.g. in static data in the
        DLL).  If it points to allocated memory, that memory will
        leak away.  Using a static buffer in the function should work,
        it's then freed when the DLL is unloaded.

        WARNING: If the function returns a non-valid pointer, Vim may
        crash!  This also happens if the function returns a number,
        because Vim thinks it's a pointer.
        For Win32 systems, {libname} should be the filename of the DLL
        without the ".DLL" suffix.  A full path is only required if
        the DLL is not in the usual places.
        For Unix: When compiling your own plugins, remember that the
        object code must be compiled as position-independant ('PIC').
        {only in Win32 on some Unix versions, when the |+libcall|
        feature is present}
        Examples: >
            :echo libcall("libc.so", "getenv", "HOME")
            :echo libcallnr("/usr/lib/libc.so", "getpid", "")
<
                            *libcallnr()*
libcallnr({libname}, {funcname}, {argument})
        Just like libcall(), but used for a function that returns an
        int instead of a string.
        {only in Win32 on some Unix versions, when the |+libcall|
        feature is present}
        Example (not very useful...): >
            :call libcallnr("libc.so", "printf", "Hello World!\n")
            :call libcallnr("libc.so", "sleep", 10)
<
                            *line()*
line({expr})    The result is a Number, which is the line number of the file
        position given with {expr}.  The accepted positions are:
            .        the cursor position
            $        the last line in the current buffer
            'x        position of mark x (if the mark is not set, 0 is
                returned)
        Note that only marks in the current file can be used.
        Examples: >
            line(".")        line number of the cursor
            line("'t")        line number of mark t
            line("'" . marker)    line number of mark marker
<                            *last-position-jump*
        This autocommand jumps to the last known position in a file
        just after opening it, if the '" mark is set: >
    :au BufReadPost * if line("'\"") | exe "normal '\"" | endif
<
line2byte({lnum})                    *line2byte()*
        Return the byte count from the start of the buffer for line
        {lnum}.  This includes the end-of-line character, depending on
        the 'fileformat' option for the current buffer.  The first
        line returns 1.
        This can also be used to get the byte count for the line just
        below the last line: >
            line2byte(line("$") + 1)
<        This is the file size plus one.
        When {lnum} is invalid, or the |+byte_offset| feature has been
        disabled at compile time, -1 is returned.
        Also see |byte2line()|, |go| and |:goto|.

lispindent({lnum})                    *lispindent()*
        Get the amount of indent for line {lnum} according the lisp
        indenting rules, as with 'lisp'.
        The indent is counted in spaces, the value of 'tabstop' is
        relevant.  {lnum} is used just like in |getline()|.
        When {lnum} is invalid or Vim was not compiled the
        |+lispindent| feature, -1 is returned.

localtime()                        *localtime()*
        Return the current time, measured as seconds since 1st Jan
        1970.  See also |strftime()| and |getftime()|.

maparg({name}[, {mode}])                *maparg()*
        Return the rhs of mapping {name} in mode {mode}.  When there
        is no mapping for {name}, an empty String is returned.
        These characters can be used for {mode}:
            "n"    Normal
            "v"    Visual
            "o"    Operator-pending
            "i"    Insert
            "c"    Cmd-line
            ""    Normal, Visual and Operator-pending
        When {mode} is omitted, the modes from "" are used.
        The {name} can have special key names, like in the ":map"
        command.  The returned String has special characters
        translated like in the output of the ":map" command listing.
        The mappings local to the current buffer are checked first,
        then the global mappings.

mapcheck({name}[, {mode}])                *mapcheck()*
        Check if there is a mapping that matches with {name} in mode
        {mode}.  See |maparg()| for {mode} and special names in
        {name}.
        A match happens with a mapping that starts with {name} and
        with a mapping which is equal to the start of {name}.

            matches mapping "a"     "ab"    "abc" ~
           mapcheck("a")    yes    yes     yes
           mapcheck("abc")    yes    yes     yes
           mapcheck("ax")    yes    no     no
           mapcheck("b")    no    no     no

        The difference with maparg() is that mapcheck() finds a
        mapping that matches with {name}, while maparg() only finds a
        mapping for {name} exactly.
        When there is no mapping that starts with {name}, an empty
        String is returned.  If there is one, the rhs of that mapping
        is returned.  If there are several mappings that start with
        {name}, the rhs of one of them is returned.
        The mappings local to the current buffer are checked first,
        then the global mappings.
        This function can be used to check if a mapping can be added
        without being ambiguous.  Example: >
    :if mapcheck("_vv") == ""
    :   map _vv :set guifont=7x13<CR>
    :endif
<        This avoids adding the "_vv" mapping when there already is a
        mapping for "_v" or for "_vvv".

match({expr}, {pat}[, {start}])                *match()*
        The result is a Number, which gives the index in {expr} where
        {pat} matches.  A match at the first character returns zero.
        If there is no match -1 is returned.  Example: >
            :echo match("testing", "ing")
<        results in "4".
        See |string-match| for how {pat} is used.
        If {start} is given, the search starts from character {start}.
        The result, however, is still the index counted from the
        first character. Example: >
            :echo match("testing", "ing", 2)
<        result is again "4". >
            :echo match("testing", "ing", 4)
<        result is again "4". >
            :echo match("testing", "t", 2)
<        result is "3".
        If {start} < 0, it will be set to 0.
        If {start} > strlen({expr}) -1 is returned.
        See |pattern| for the patterns that are accepted.
        The 'ignorecase' option is used to set the ignore-caseness of
        the pattern.  'smartcase' is NOT used.  The matching is always
        done like 'magic' is set and 'cpoptions' is empty.

matchend({expr}, {pat}[, {start}])            *matchend()*
        Same as match(), but return the index of first character after
        the match.  Example: >
            :echo matchend("testing", "ing")
<        results in "7".
        The {start}, if given, has the same meaning as for match(). >
            :echo matchend("testing", "ing", 2)
<        results in "7". >
            :echo matchend("testing", "ing", 5)
<        result is "-1".

matchstr({expr}, {pat}[, {start}])            *matchstr()*
        Same as match(), but return the matched string.  Example: >
            :echo matchstr("testing", "ing")
<        results in "ing".
        When there is no match "" is returned.
        The {start}, if given, has the same meaning as for match(). >
            :echo matchstr("testing", "ing", 2)
<        results in "ing". >
            :echo matchstr("testing", "ing", 5)
<        result is "".

                            *mode()*
mode()        Return a string that indicates the current mode:
            n    Normal
            v    Visual by character
            V    Visual by line
            CTRL-V    Visual blockwise
            s    Select by character
            S    Select by line
            CTRL-S    Select blockwise
            i    Insert
            R    Replace
            c    Command-line
            r    Hit-enter prompt
        This is useful in the 'statusline' option.  In most other
        places it always returns "c" or "n".

nextnonblank({lnum})                    *nextnonblank()*
        Return the line number of the first line at or below {lnum}
        that is not blank.  Example: >
            if getline(nextnonblank(1)) =~ "Java"
<        When {lnum} is invalid or there is no non-blank line at or
        below it, zero is returned.
        See also |prevnonblank()|.

nr2char({expr})                        *nr2char()*
        Return a string with a single character, which has the ASCII
        value {expr}.  Examples: >
            nr2char(64)        returns "@"
            nr2char(32)        returns " "
<
prevnonblank({lnum})                    *prevnonblank()*
        Return the line number of the first line at or above {lnum}
        that is not blank.  Example: >
            let ind = indent(prevnonblank(v:lnum - 1))
<        When {lnum} is invalid or there is no non-blank line at or
        above it, zero is returned.

                            *remote_expr()*
remote_expr({server}, {string} [, {idvar}])
        Send the {string} to {server}.  The string is sent as an
        expression and the result is returned after evaluation.
        If {idvar} is present, it is taken as the name of a
        variable and a {serverid} for later use with
        remote_read() is stored there.
        See also |clientserver| |RemoteReply|.
        {only available when compiled with the |+clientserver| feature}
        Note: Any errors will be reported in the server and may mess
        up the display.
        Examples: >
            :echo remote_expr("gvim", "2+2")
            :echo remote_expr("gvim-001", "b:current_syntax")
<

remote_foreground({server})                *remote_foreground()*
        Move the Vim server with the name {server} to the foreground.
        This works like: >
            remote_expr({server}, "foreground()")
<        Except that on Win32 systems the client does the work, to work
        around the problem that the OS doesn't always allow the server
        to bring itself to the foreground.
        {only in the Win32, Athena, Motif and GTK GUI versions and the
        Win32 console version}


remote_peek({serverid} [, {retvar}])        *remote_peek()*
        Returns a positive number if there are available strings
        from {serverid}.  Copies any reply string into the variable
        {retvar} if specified.  {retvar} must be a string with the
        name of a variable.
        Returns zero if none are available.
        See also |clientserver|.
        {only available when compiled with the |+clientserver| feature}
        Examples: >
            :let repl = ""
            :echo "PEEK: ".remote_peek(id, "repl").": ".repl

remote_read({serverid})                *remote_read()*
        Return the oldest available reply from {serverid} and consume
        it.  It blocks until a reply is available.
        See also |clientserver|.
        {only available when compiled with the |+clientserver| feature}
        Examples: >
            :echo remote_read(id)
<
                            *remote_send()* *E241*
remote_send({server}, {string} [, {idvar}])
        Send the {string} to {server}.  The string is sent as
        input keys and the function returns immediately.
        If {idvar} is present, it is taken as the name of a
        variable and a {serverid} for later use with
        remote_read() is stored there.
        See also |clientserver| |RemoteReply|.
        {only available when compiled with the |+clientserver| feature}
        Note: Any errors will be reported in the server and may mess
        up the display.
        Examples: >
        :echo remote_send("gvim", ":DropAndReply ".file, "serverid").
         \ remote_read(serverid)

        :autocmd NONE RemoteReply *
         \ echo remote_read(expand("<amatch>"))
        :echo remote_send("gvim", ":sleep 10 | echo ".
         \ 'server2client(expand("<client>"), "HELLO")<CR>')


rename({from}, {to})                    *rename()*
        Rename the file by the name {from} to the name {to}.  This
        should also work to move files across file systems.  The
        result is a Number, which is 0 if the file was renamed
        successfully, and non-zero when the renaming failed.

resolve({filename})                    *resolve()*
        On MS-Windows, when {filename} is a shortcut (a .lnk file),
        returns the path the shortcut points to.
        On Unix, when {filename} is a symbolic link, returns the path
        the symlink points to.  This only happens once, the returned
        path could be a symlink again.
        Otherwise {filename} is returned.

search({pattern} [, {flags}])                *search()*
        Search for regexp pattern {pattern}.  The search starts at the
        cursor position.
        {flags} is a String, which can contain these character flags:
        'b'    search backward instead of forward
        'w'    wrap around the end of the file
        'W'    don't wrap around the end of the file
        If neither 'w' or 'W' is given, the 'wrapscan' option applies.

        When a match has been found its line number is returned, and
        the cursor will be positioned at the match.  If there is no
        match a 0 is returned and the cursor doesn't move.  No error
        message is given.

        Example (goes over all files in the argument list): >
            :let n = 1
            :while n <= argc()        " loop over all files in arglist
            :  exe "argument " . n
            :  " start at the last char in the file and wrap for the
            :  " first search to find match at start of file
            :  normal G$
            :  let flags = "w"
            :  while search("foo", flags) > 0
            :    s/foo/bar/g
            :     let flags = "W"
            :  endwhile
            :  update            " write the file if modified
            :  let n = n + 1
            :endwhile
<
                            *searchpair()*
searchpair({start}, {middle}, {end} [, {flags} [, {skip}]])
        Search for the match of a nested start-end pair.  This can be
        used to find the "endif" that matches an "if", while other
        if/endif pairs in between are ignored.
        The search starts at the cursor.  If a match is found, the
        cursor is positioned at it and the line number is returned.
        If no match is found 0 or -1 is returned and the cursor
        doesn't move.  No error message is given.

        {start}, {middle} and {end} are patterns, see |pattern|.  They
        must not contain \( \) pairs.  Use of \%( \) is allowed.  When
        {middle} is not empty, it is found when searching from either
        direction, but only when not in a nested start-end pair.  A
        typical use is: >
            searchpair("if", "else", "endif")
<        By leaving {middle} empty the "else" is skipped.

        {flags} are used like with |search()|.  Additionally:
        'n'    do Not move the cursor
        'r'    repeat until no more matches found; will find the
            outer pair
        'm'    return number of matches instead of line number with
            the match; will only be > 1 when 'r' is used.

        When a match for {start}, {middle} or {end} is found, the
        {skip} expression is evaluated with the cursor positioned on
        the start of the match.  It should return non-zero if this
        match is to be skipped.  E.g., because it is inside a comment
        or a string.
        When {skip} is omitted or empty, every match is accepted.
        When evaluating {skip} causes an error the search is aborted
        and -1 returned.

        The value of 'ignorecase' is used.  'magic' is ignored, the
        patterns are used like it's on.

        The search starts exactly at the cursor.  A match with
        {start}, {middle} or {end} at the next character, in the
        direction of searching, is the first one found.  Example: >
            if 1
              if 2
              endif 2
            endif 1
<        When starting at the "if 2", with the cursor on the "i", and
        searching forwards, the "endif 2" is found.  When starting on
        the character just before the "if 2", the "endif 1" will be
        found.  That's because the "if 2" will be found first, and
        then this is considered to be a nested if/endif from "if 2" to
        "endif 2".

        Example, to find the "endif" command in a Vim script: >

    :echo searchpair('\<if\>', '\<el\%[seif]\>', '\<en\%[dif]\>', 'W',
            \ 'getline(".") =~ "^\\s*\""')

<        The cursor must be at or after the "if" for which a match is
        to be found.  Note that single-quote strings are used to avoid
        having to double the backslashes.  The skip expression only
        catches comments at the start of a line, not after a command.
        Also, a word "en" or "if" halfway a line is considered a
        match.
        Another example, to search for the matching "{" of a "}": >

    :echo searchpair('{', '', '}', 'bW')

<        This works when the cursor is at or before the "}" for which a
        match is to be found.  To reject matches that syntax
        highlighting recognized as strings: >

    :echo searchpair('{', '', '}', 'bW',
         \ 'synIDattr(synID(line("."), col("."), 0), "name") =~? "string"')
<
server2client( {clientid}, {string})            *server2client()*
        Send a reply string to {clientid}. The most recent {clientid}
        that sent a string can be retrieved with expand("<client>").
        {only available when compiled with the |+clientserver| feature}
        Note:
        This id has to be stored before the next command can be
        received. Ie. before returning from the received command and
        before calling any commands that waits for input.
        See also |clientserver|.
        Examples: >
        :echo server2client(expand("<client>"), "HELLO")
<
serverlist()                    *serverlist()* *E240*
        Return a list of available server names. One per line.
        See also |clientserver|.
        {only available when compiled with the |+clientserver| feature}
        Examples: >
        :echo serverlist()
<
setbufvar({expr}, {varname}, {val})            *setbufvar()*
        Set option or local variable {varname} in buffer {expr} to
        {val}.
        This also works for a global or local window option, but it
        doesn't work for a global or local window variable.
        For a local window option the global value is unchanged.
        For the use of {expr}, see |bufname()| above.
        Note that the variable name without "b:" must be used.
        Examples: >
            :call setbufvar(1, "&mod", 1)
            :call setbufvar("todo", "myvar", "foobar")
<
setline({lnum}, {line})                    *setline()*
        Set line {lnum} of the current buffer to {line}.  If this
        succeeds, 0 is returned.  If this fails (most likely because
        {lnum} is invalid) 1 is returned.  Example: >
            :call setline(5, strftime("%c"))
<        Note: The '[ and '] marks are not set.

setwinvar({nr}, {varname}, {val})            *setwinvar()*
        Set option or local variable {varname} in window {nr} to
        {val}.
        This also works for a global or local buffer option, but it
        doesn't work for a global or local buffer variable.
        For a local buffer option the global value is unchanged.
        Note that the variable name without "w:" must be used.
        Examples: >
            :call setwinvar(1, "&list", 0)
            :call setwinvar(2, "myvar", "foobar")
<
strftime({format} [, {time}])                *strftime()*
        The result is a String, which is a formatted date and time, as
        specified by the {format} string.  The given {time} is used,
        or the current time if no time is given.  The accepted
        {format} depends on your system, thus this is not portable!
        See the manual page of the C function strftime() for the
        format.  The maximum length of the result is 80 characters.
        See also |localtime()| and |getftime()|.
        The language can be changed with the |:language| command.
        Examples: >
          :echo strftime("%c")           Sun Apr 27 11:49:23 1997
          :echo strftime("%Y %b %d %X")       1997 Apr 27 11:53:25
          :echo strftime("%y%m%d %T")       970427 11:53:55
          :echo strftime("%H:%M")       11:55
          :echo strftime("%c", getftime("file.c"))
                           Show mod time of file.c.
<
stridx({haystack}, {needle})                *stridx()*
        The result is a Number, which gives the index in {haystack} of
        the first occurrence of the String {needle} in the String
        {haystack}. The search is done case-sensitive. For advanced
        searches use |match()|.
        If the {needle} does not occur in {haystack} it returns -1.
        See also |strridx()|. Examples: >
          :echo stridx("An Example", "Example")         3
          :echo stridx("Starting point", "Start")    0
          :echo stridx("Starting point", "start")   -1
<
                            *strlen()*
strlen({expr})    The result is a Number, which is the length of the String
        {expr}.

strpart({src}, {start}[, {len}])            *strpart()*
        The result is a String, which is part of {src},
        starting from character {start}, with the length {len}.
        When non-existing characters are included, this doesn't result
        in an error, the characters are simply omitted.
        If {len} is missing, the copy continues from {start} till
        the end of the {src}. >
            strpart("abcdefg", 3, 2)    == "de"
            strpart("abcdefg", -2, 4)   == "ab"
            strpart("abcdefg", 5, 4)    == "fg"
            strpart("abcdefg", 3)       == "defg"
<        Note: To get the first character, {start} must be 0.  For
        example, to get three characters under and after the cursor: >
            strpart(getline(line(".")), col(".") - 1, 3)
<
strridx({haystack}, {needle})                *strridx()*
        The result is a Number, which gives the index in {haystack} of
        the last occurrence of the String {needle} in the String
        {haystack}. The search is done case-sensitive. For advanced
        searches use |match()|.
        If the {needle} does not occur in {haystack} it returns -1.
        See also |stridx()|. Examples: >
          :echo strridx("an angry armadillo", "an")         3
<
strtrans({expr})                    *strtrans()*
        The result is a String, which is {expr} with all unprintable
        characters translated into printable characters |'isprint'|.
        Like they are shown in a window.  Example: >
            echo strtrans(@a)
<        This displays a newline in register a as "^@" instead of
        starting a new line.

submatch({nr})                        *submatch()*
        Only for an expression in a |:substitute| command.  Returns
        the {nr}'th submatch of the matched text  When {nr} is 0
        the whole matched text is returned.
        Example: >
            :s/\d\+/\=submatch(0) + 1/
<        This finds the first number in the line and adds one to it.

substitute({expr}, {pat}, {sub}, {flags})        *substitute()*
        The result is a String, which is a copy of {expr}, in which
        the first match of {pat} is replaced with {sub}.  This works
        like the ":substitute" command (without any flags).  But the
        matching with {pat} is always done like the 'magic' option is
        set and 'cpoptions' is empty (to make scripts portable).
        See |string-match| for how {pat} is used.
        And a "~" in {sub} is not replaced with the previous {sub}.
        Note that some codes in {sub} have a special meaning
        |sub-replace-special|.  For example, to replace something with
        a literal "\n", use "\\\\n" or '\\n'.
        When {pat} does not match in {expr}, {expr} is returned
        unmodified.
        When {flags} is "g", all matches of {pat} in {expr} are
        replaced.  Otherwise {flags} should be "".
        Example: >
            :let &path = substitute(&path, ",\\=[^,]*$", "", "")
<        This removes the last component of the 'path' option. >
            :echo substitute("testing", ".*", "\\U\\0", "")
<        results in "TESTING".

synID({line}, {col}, {trans})                *synID()*
        The result is a Number, which is the syntax ID at the position
        {line} and {col} in the current window.
        The syntax ID can be used with |synIDattr()| and
        |synIDtrans()| to obtain syntax information about text.
        {col} is 1 for the leftmost column, {line} is 1 for the first
        line.
        When {trans} is non-zero, transparent items are reduced to the
        item that they reveal.  This is useful when wanting to know
        the effective color.  When {trans} is zero, the transparent
        item is returned.  This is useful when wanting to know which
        syntax item is effective (e.g. inside parens).
        Warning: This function can be very slow.  Best speed is
        obtained by going through the file in forward direction.

        Example (echos the name of the syntax item under the cursor): >
            :echo synIDattr(synID(line("."), col("."), 1), "name")
<
synIDattr({synID}, {what} [, {mode}])            *synIDattr()*
        The result is a String, which is the {what} attribute of
        syntax ID {synID}.  This can be used to obtain information
        about a syntax item.
        {mode} can be "gui", "cterm" or "term", to get the attributes
        for that mode.  When {mode} is omitted, or an invalid value is
        used, the attributes for the currently active highlighting are
        used (GUI, cterm or term).
        Use synIDtrans() to follow linked highlight groups.
        {what}        result
        "name"        the name of the syntax item
        "fg"        foreground color (GUI: color name, cterm:
                color number as a string, term: empty string)
        "bg"        background color (like "fg")
        "fg#"        like "fg", but name in "#RRGGBB" form
        "bg#"        like "bg", but name in "#RRGGBB" form
        "bold"        "1" if bold
        "italic"    "1" if italic
        "reverse"    "1" if reverse
        "inverse"    "1" if inverse (= reverse)
        "underline"    "1" if underlined

        When the GUI is not running or the cterm mode is asked for,
        "fg#" is equal to "fg" and "bg#" is equal to "bg".

        Example (echos the color of the syntax item under the cursor): >
    :echo synIDattr(synIDtrans(synID(line("."), col("."), 1)), "fg")
<
synIDtrans({synID})                    *synIDtrans()*
        The result is a Number, which is the translated syntax ID of
        {synID}.  This is the syntax group ID of what is being used to
        highlight the character.  Highlight links given with
        ":highlight link" are followed.

                            *system()*
system({expr})    Get the output of the shell command {expr}.  Note: newlines
        in {expr} may cause the command to fail.  This is not to be
        used for interactive commands.
        The result is a String.  To make the result more
        system-independent, the shell output is filtered to replace
        <CR> with <NL> for Macintosh, and <CR><NL> with <NL> for
        DOS-like systems.
        'shellredir' is used to capture the output of the command.
        Depending on 'shell', you might be able to capture stdout with
        ">" and stdout plus stderr with ">&" (csh) or use "2>" to
        capture stderr (sh).
        The resulting error code can be found in |v:shell_error|.
        This function will fail in |restricted-mode|.

tempname()                    *tempname()* *temp-file-name*
        The result is a String, which is the name of a file that
        doesn't exist.  It can be used for a temporary file.  The name
        is different for at least 26 consecutive calls.  Example: >
            :let tmpfile = tempname()
            :exe "redir > " . tmpfile
<        For Unix, the file will be in a private directory (only
        accessible by the current user) to avoid security problems
        (e.g., a symlink attack or other people reading your file).
        When Vim exits the directory and all files in it are deleted.

tolower({expr})                        *tolower()*
        The result is a copy of the String given, with all uppercase
        characters turned into lowercase (just like applying |gu| to
        the string).

toupper({expr})                        *toupper()*
        The result is a copy of the String given, with all lowercase
        characters turned into uppercase (just like applying |gU| to
        the string).

type({expr})                        *type()*
        The result is a Number:
            0 if {expr} has the type Number
            1 if {expr} has the type String

virtcol({expr})                        *virtcol()*
        The result is a Number, which is the screen column of the file
        position given with {expr}.  That is, the last screen position
        occupied by the character at that position, when the screen
        would be of unlimited width.  When there is a <Tab> at the
        position, the returned Number will be the column at the end of
        the <Tab>.  For example, for a <Tab> in column 1, with 'ts'
        set to 8, it returns 8;
        The accepted positions are:
            .        the cursor position
            $        the end of the cursor line (the result is the
                number of displayed characters in the cursor line
                plus one)
            'x        position of mark x (if the mark is not set, 0 is
                returned)
        Note that only marks in the current file can be used.
        Examples: >
  virtcol(".")       with text "foo^Lbar", with cursor on the "^L", returns 5
  virtcol("$")       with text "foo^Lbar", returns 9
  virtcol("'t")    with text "    there", with 't at 'h', returns 6
<        The first column is 1.  0 is returned for an error.

visualmode()                        *visualmode()*
        The result is a String, which describes the last Visual mode
        used.  Initially it returns an empty string, but once Visual
        mode has been used, it returns "v", "V", or "<CTRL-V>" (a
        single CTRL-V character) for character-wise, line-wise, or
        block-wise Visual mode respectively.
        Example: >
            :exe "normal " . visualmode()
<        This enters the same Visual mode as before.  It is also useful
        in scripts if you wish to act differently depending on the
        Visual mode that was used.

                            *winbufnr()*
winbufnr({nr})    The result is a Number, which is the number of the buffer
        associated with window {nr}. When {nr} is zero, the number of
        the buffer in the current window is returned.  When window
        {nr} doesn't exist, -1 is returned.
        Example: >
  :echo "The file in the current window is " . bufname(winbufnr(0))
<
                            *wincol()*
wincol()    The result is a Number, which is the virtual column of the
        cursor in the window.  This is counting screen cells from the
        left side of the window.  The leftmost column is one.

winheight({nr})                        *winheight()*
        The result is a Number, which is the height of window {nr}.
        When {nr} is zero, the height of the current window is
        returned.  When window {nr} doesn't exist, -1 is returned.
        An existing window always has a height of zero or more.
        Examples: >
  :echo "The current window has " . winheight(0) . " lines."
<
                            *winline()*
winline()    The result is a Number, which is the screen line of the cursor
        in the window.  This is counting screen lines from the top of
        the window.  The first line is one.

                            *winnr()*
winnr()        The result is a Number, which is the number of the current
        window.  The top window has number 1.

winwidth({nr})                        *winwidth()*
        The result is a Number, which is the width of window {nr}.
        When {nr} is zero, the width of the current window is
        returned.  When window {nr} doesn't exist, -1 is returned.
        An existing window always has a width of zero or more.
        Examples: >
  :echo "The current window has " . winwidth(0) . " columns."
  :if winwidth(0) <= 50
  :  exe "normal 50\<C-W>|"
  :endif
<

                            *feature-list*
There are two types of features:
1.  Features that are only supported when they have been enabled when Vim
    was compiled |+feature-list|.  Example: >
    :if has("cindent")
2.  Features that are only supported when certain conditions have been met.
    Example: >
    :if has("gui_running")

all_builtin_terms    Compiled with all builtin terminals enabled.
amiga            Amiga version of Vim.
arp            Compiled with ARP support (Amiga).
autocmd            Compiled with autocommands support.
balloon_eval        Compiled with |balloon-eval| support.
beos            BeOS version of Vim.
browse            Compiled with |:browse| support, and browse() will
            work.
builtin_terms        Compiled with some builtin terminals.
byte_offset        Compiled with support for 'o' in 'statusline'
cindent            Compiled with 'cindent' support.
clientserver        Compiled with remote invocation support |clientserver|.
clipboard        Compiled with 'clipboard' support.
cmdline_compl        Compiled with |cmdline-completion| support.
cmdline_hist        Compiled with |cmdline-history| support.
cmdline_info        Compiled with 'showcmd' and 'ruler' support.
comments        Compiled with |'comments'| support.
cryptv            Compiled with encryption support |encryption|.
cscope            Compiled with |cscope| support.
compatible        Compiled to be very Vi compatible.
debug            Compiled with "DEBUG" defined.
dialog_con        Compiled with console dialog support.
dialog_gui        Compiled with GUI dialog support.
diff            Compiled with |vimdiff| and 'diff' support.
digraphs        Compiled with support for digraphs.
dos32            32 bits DOS (DJGPP) version of Vim.
dos16            16 bits DOS version of Vim.
ebcdic            Compiled on a machine with ebcdic character set.
emacs_tags        Compiled with support for Emacs tags.
eval            Compiled with expression evaluation support.  Always
            true, of course!
ex_extra        Compiled with extra Ex commands |+ex_extra|.
extra_search        Compiled with support for |'incsearch'| and
            |'hlsearch'|
farsi            Compiled with Farsi support |farsi|.
file_in_path        Compiled with support for |gf| and |<cfile>|
find_in_path        Compiled with support for include file searches
            |+find_in_path|.
fname_case        Case in file names matters (for Amiga, MS-DOS, and
            Windows this is not present).
folding            Compiled with |folding| support.
footer            Compiled with GUI footer support. |gui-footer|
fork            Compiled to use fork()/exec() instead of system().
gettext            Compiled with message translation |multi-lang|
gui            Compiled with GUI enabled.
gui_athena        Compiled with Athena GUI.
gui_beos        Compiled with BeOs GUI.
gui_gtk            Compiled with GTK+ GUI.
gui_mac            Compiled with Macintosh GUI.
gui_motif        Compiled with Motif GUI.
gui_photon        Compiled with Photon GUI.
gui_win32        Compiled with MS Windows Win32 GUI.
gui_win32s        idem, and Win32s system being used (Windows 3.1)
gui_running        Vim is running in the GUI, or it will start soon.
hangul_input        Compiled with Hangul input support. |hangul|
iconv            Can use iconv() for coversion.
insert_expand        Compiled with support for CTRL-X expansion commands in
            Insert mode.
jumplist        Compiled with |jumplist| support.
keymap            Compiled with 'keymap' support.
langmap            Compiled with 'langmap' support.
libcall            Compiled with |libcall()| support.
linebreak        Compiled with 'linebreak', 'breakat' and 'showbreak'
            support.
lispindent        Compiled with support for lisp indenting.
listcmds        Compiled with commands for the buffer list |:files|
            and the argument list |arglist|.
localmap        Compiled with local mappings and abbr. |:map-local|
mac            Macintosh version of Vim.
menu            Compiled with support for |:menu|.
mksession        Compiled with support for |:mksession|.
modify_fname        Compiled with file name modifiers. |filename-modifiers|
mouse            Compiled with support mouse.
mouseshape        Compiled with support for 'mouseshape'.
mouse_dec        Compiled with support for Dec terminal mouse.
mouse_gpm        Compiled with support for gpm (Linux console mouse)
mouse_netterm        Compiled with support for netterm mouse.
mouse_pterm        Compiled with support for qnx pterm mouse.
mouse_xterm        Compiled with support for xterm mouse.
multi_byte        Compiled with support for editing Korean et al.
multi_byte_ime        Compiled with support for IME input method.
multi_lang        Compiled with support for multiple languages.
ole            Compiled with OLE automation support for Win32.
os2            OS/2 version of Vim.
osfiletype        Compiled with support for osfiletypes |+osfiletype|
path_extra        Compiled with up/downwards search in 'path' and 'tags'
perl            Compiled with Perl interface.
postscript        Compiled with PostScript file printing.
printer            Compiled with |:hardcopy| support.
python            Compiled with Python interface.
qnx            QNX version of vim.
quickfix        Compiled with |quickfix| support.
rightleft        Compiled with 'rightleft' support.
ruby            Compiled with Ruby interface |ruby|.
scrollbind        Compiled with 'scrollbind' support.
showcmd            Compiled with 'showcmd' support.
signs            Compiled with |:sign| support.
smartindent        Compiled with 'smartindent' support.
sniff            Compiled with SniFF interface support.
statusline        Compiled with support for 'statusline', 'rulerformat'
            and special formats of 'titlestring' and 'iconstring'.
sun_workshop        Compiled with support for Sun |workshop|.
syntax            Compiled with syntax highlighting support.
syntax_items        There are active syntax highlighting items for the
            current buffer.
system            Compiled to use system() instead of fork()/exec().
tag_binary        Compiled with binary searching in tags files
            |tag-binary-search|.
tag_old_static        Compiled with support for old static tags
            |tag-old-static|.
tag_any_white        Compiled with support for any white characters in tags
            files |tag-any-white|.
tcl            Compiled with Tcl interface.
terminfo        Compiled with terminfo instead of termcap.
termresponse        Compiled with support for |t_RV| and |v:termresponse|.
textobjects        Compiled with support for |text-objects|.
tgetent            Compiled with tgetent support, able to use a termcap
            or terminfo file.
title            Compiled with window title support |'title'|.
toolbar            Compiled with support for |gui-toolbar|.
unix            Unix version of Vim.
user_commands        User-defined commands.
viminfo            Compiled with viminfo support.
vim_starting        True while initial source'ing takes place.
vertsplit        Compiled with vertically split windows |:vsplit|.
virtualedit        Compiled with 'virtualedit' option.
visual            Compiled with Visual mode.
visualextra        Compiled with extra Visual mode commands.
            |blockwise-operators|.
vms            VMS version of Vim.
vreplace        Compiled with |gR| and |gr| commands.
wildignore        Compiled with 'wildignore' option.
wildmenu        Compiled with 'wildmenu' option.
windows            Compiled with support for more than one window.
winaltkeys        Compiled with 'winaltkeys' option.
win16            Win16 version of Vim (MS-Windows 3.1).
win32            Win32 version of Vim (MS-Windows 95/98/ME/NT/2000/XP).
win95            Win32 version for MS-Windows 95/98/ME.
writebackup        Compiled with 'writebackup' default on.
xfontset        Compiled with X fontset support |xfontset|.
xim            Compiled with X input method support |xim|.
xterm_clipboard        Compiled with support for xterm clipboard.
xterm_save        Compiled with support for saving and restoring the
            xterm screen.
x11            Compiled with X11 support.

                            *string-match*
Matching a pattern in a String

A regexp pattern as explained at |pattern| is normally used to find a match in
the buffer lines.  When a pattern is used to find a match in a String, almost
everything works in the same way.  The difference is that a String is handled
like it is one line.  When it contains a "\n" character, this is not seen as a
line break for the pattern.  It can be matched with a "\n" in the pattern, or
with ".".  Example: >
    :let a = "aaaa\nxxxx"
    :echo matchstr(a, "..\n..")
    aa
    xx
    :echo matchstr(a, "a.x")
    a
    x

Don't forget that "^" will only match at the first character of the String and
"$" at the last character of the string.  They don't match after or before a
"\n".

==============================================================================
5. Defining functions                    *user-functions*

New functions can be defined.  These can be called just like builtin
functions.

The function name must start with an uppercase letter, to avoid confusion with
builtin functions.  To prevent from using the same name in different scripts
avoid obvious, short names.  A good habit is to start the function name with
the name of the script, e.g., "HTMLcolor()".

It's also possible to use curly braces, see |curly-braces-names|.

                            *local-function*
A function local to a script must start with "s:".  A local script function
can only be called from within the script and from functions, user commands
and autocommands defined in the script.  It is also possible to call the
function from a mappings defined in the script, but then |<SID>| must be used
instead of "s:" when the mapping is expanded outside of the script.

                    *:fu* *:function* *E128* *E129* *E123*
:fu[nction]        List all functions and their arguments.

:fu[nction] {name}    List function {name}.
                            *E124* *E125*
:fu[nction][!] {name}([arguments]) [range] [abort]
            Define a new function by the name {name}.  The name
            must be made of alphanumeric characters and '_', and
            must start with a capital.
                        *function-argument* *a:var*
            An argument can be defined by giving its name.  In the
            function this can then be used as "a:name" ("a:" for
            argument).
            Up to 20 arguments can be given, separated by commas.
            Finally, an argument "..." can be specified, which
            means that more arguments may be following.  In the
            function they can be used as "a:1", "a:2", etc.  "a:0"
            is set to the number of extra arguments (which can be
            0).
            When not using "...", the number of arguments in a
            function call must be equal the number of named
            arguments.  When using "...", the number of arguments
            may be larger.
            It is also possible to define a function without any
            arguments.  You must still supply the () then.
            The body of the function follows in the next lines,
            until the matching |:endfunction|.  It is allowed to
            define another function inside a function body.
                                *E127* *E122*
            When a function by this name already exists and [!] is
            not used an error message is given.  When [!] is used,
            an existing function is silently replaced.
            When the [range] argument is added, the function is
            expected to take care of a range itself.  The range is
            passed as "a:firstline" and "a:lastline".  If [range]
            is excluded, ":{range}call" will call the function for
            each line in the range, with the cursor on the start
            of each line.  See |function-range-example|.
            When the [abort] argument is added, the function will
            abort as soon as an error is detected.
            The last used search pattern and the redo command "."
            will not be changed by the function.

                    *:endf* *:endfunction* *E126* *E193*
:endf[unction]        The end of a function definition.

                    *:delf* *:delfunction* *E130* *E131*
:delf[unction] {name}    Delete function {name}.

                            *:retu* *:return* *E133*
:retu[rn] [expr]    Return from a function.  When "[expr]" is given, it is
            evaluated and returned as the result of the function.
            If "[expr]" is not given, the number 0 is returned.
            When a function ends without an explicit ":return",
            the number 0 is returned.
            Note that there is no check for unreachable lines,
            thus there is no warning if commands follow ":return".

Inside a function variables can be used.  These are local variables, which
will disappear when the function returns.  Global variables need to be
accessed with "g:".

Example: >
  :function Table(title, ...)
  :  echohl Title
  :  echo a:title
  :  echohl None
  :  let idx = 1
  :  while idx <= a:0
  :    exe "echo a:" . idx
  :    let idx = idx + 1
  :  endwhile
  :  return idx
  :endfunction

This function can then be called with: >
  let lines = Table("Table", "line1", "line2")
  let lines = Table("Empty Table")

To return more than one value, pass the name of a global variable: >
  :function Compute(n1, n2, divname)
  :  if a:n2 == 0
  :    return "fail"
  :  endif
  :  exe "let g:" . a:divname . " = ". a:n1 / a:n2
  :  return "ok"
  :endfunction

This function can then be called with: >
  :let success = Compute(13, 1324, "div")
  :if success == "ok"
  :  echo div
  :endif

An alternative is to return a command that can be executed.  This also works
with local variables in a calling function.  Example: >
  :function Foo()
  :  execute Bar()
  :  echo "line " . lnum . " column " . col
  :endfunction

  :function Bar()
  :  return "let lnum = " . line(".") . " | let col = " . col(".")
  :endfunction

The names "lnum" and "col" could also be passed as argument to Bar(), to allow
the caller to set the names.

                            *:cal* *:call* *E107*
:[range]cal[l] {name}([arguments])
        Call a function.  The name of the function and its arguments
        are as specified with |:function|.  Up to 20 arguments can be
        used.
        Without a range and for functions that accept a range, the
        function is called once.  When a range is given the cursor is
        positioned at the start of the first line before executing the
        function.
        When a range is given and the function doesn't handle it
        itself, the function is executed for each line in the range,
        with the cursor in the first column of that line.  The cursor
        is left at the last line (possibly moved by the last function
        call).  The arguments are re-evaluated for each line.  Thus
        this works:
                        *function-range-example*  >
    :function Mynumber(arg)
    :  echo line(".") . " " . a:arg
    :endfunction
    :1,5call Mynumber(getline("."))
<
        The "a:firstline" and "a:lastline" are defined anyway, they
        can be used to do something different at the start or end of
        the range.

        Example of a function that handles the range itself: >

    :function Cont() range
    :  execute (a:firstline + 1) . "," . a:lastline . 's/^/\t\\ '
    :endfunction
    :4,8call Cont()
<
        This function inserts the continuation character "\" in front
        of all the lines in the range, except the first one.

                                *E132*
The recursiveness of user functions is restricted with the |'maxfuncdepth'|
option.

                            *autoload-functions*
When using many or large functions, it's possible to automatically define them
only when they are used.  Example: >

    :au FuncUndefined BufNet* source ~/vim/bufnetfuncs.vim

The file "~/vim/bufnetfuncs.vim" should then define functions that start with
"BufNet".  Also see |FuncUndefined|.

==============================================================================
6. Curly braces names                    *curly-braces-names*

Wherever you can use a variable, you can use a "curly braces name" variable.
This is a regular variable name with one or more expressions wrapped in braces
{} like this: >
    my_{adjective}_variable

When Vim encounters this, it evaluates the expression inside the braces, puts
that in place of the expression, and re-interprets the whole as a variable
name.  So in the above example, if the variable "adjective" was set to
"noisy", then the reference would be to "my_noisy_variable", whereas if
"adjective" was set to "quiet", then it would be to "my_quiet_variable".

One application for this is to create a set of variables governed by an option
value.  For example, the statement >
    echo my_{&background}_message

would output the contents of "my_dark_message" or "my_light_message" depending
on the current value of 'background'.

You can use multiple brace pairs: >
    echo my_{adverb}_{adjective}_message
..or even nest them: >
    echo my_{ad{end_of_word}}_message
where "end_of_word" is either "verb" or "jective"

However, the expression inside the braces must evaluate to a valid single
variable name. e.g. this is invalid: >
    :let foo='a + b'
    :echo c{foo}d
.. since the result of expansion is "ca + bd", which is not a variable name.

                        *curly-braces-function-names*
You can call and define functions by an evaluated name in a similar way.
Example: >
    :let func_end='whizz'
    :call my_func_{func_end}(parameter)
<
This would call the function "my_func_whizz(parameter)"

==============================================================================
7. Commands                        *expression-commands*

:let {var-name} = {expr1}                *:let* *E18*
            Set internal variable {var-name} to the result of the
            expression {expr1}.  The variable will get the type
            from the {expr}.  if {var-name} didn't exist yet, it
            is created.

:let ${env-name} = {expr1}            *:let-environment* *:let-$*
            Set environment variable {env-name} to the result of
            the expression {expr1}.  The type is always String.

:let @{reg-name} = {expr1}            *:let-register* *:let-@*
            Write the result of the expression {expr1} in register
            {reg-name}.  {reg-name} must be a single letter, and
            must be the name of a writable register (see
            |registers|).  "@@" can be used for the unnamed
            register, "@/" for the search pattern.
            If the result of {expr1} ends in a <CR> or <NL>, the
            register will be linewise, otherwise it will be set to
            characterwise.
            This can be used to clear the last search pattern: >
                :let @/ = ""
<            This is different from searching for an empty string,
            that would match everywhere.

:let &{option-name} = {expr1}            *:let-option* *:let-star*
            Set option {option-name} to the result of the
            expression {expr1}.  The value is always converted to
            the type of the option.
            For an option local to a window or buffer the effect
            is just like using the |:set| command: both the local
            value and the global value is changed.

:let &l:{option-name} = {expr1}
            Like above, but only set the local value of an option
            (if there is one).  Works like |:setlocal|.

:let &g:{option-name} = {expr1}
            Like above, but only set the global value of an option
            (if there is one).  Works like |:setglobal|.

                            *E106*
:let {var-name}    ..    List the value of variable {var-name}.  Several
            variable names may be given.

:let            Liset the values of all variables.

                            *:unlet* *:unl* *E108*
:unl[et][!] {var-name} ...
            Remove the internal variable {var-name}.  Several
            variable names can be given, they are all removed.
            With [!] no error message is given for non-existing
            variables.

:if {expr1}                    *:if* *:endif* *:en* *E171*
:en[dif]        Execute the commands until the next matching ":else"
            or ":endif" if {expr1} evaluates to non-zero.

            From Vim version 4.5 until 5.0, every Ex command in
            between the ":if" and ":endif" is ignored.  These two
            commands were just to allow for future expansions in a
            backwards compatible way.  Nesting was allowed.  Note
            that any ":else" or ":elseif" was ignored, the "else"
            part was not executed either.

            You can use this to remain compatible with older
            versions: >
                :if version >= 500
                :  version-5-specific-commands
                :endif
<
                            *:else* *:el*
:el[se]            Execute the commands until the next matching ":else"
            or ":endif" if they previously were not being
            executed.

                            *:elseif* *:elsei*
:elsei[f] {expr1}    Short for ":else" ":if", with the addition that there
            is no extra ":endif".

:wh[ile] {expr1}        *:while* *:endwhile* *:wh* *:endw* *E170*
:endw[hile]        Repeat the commands between ":while" and ":endwhile",
            as long as {expr1} evaluates to non-zero.
            When an error is detected from a command inside the
            loop, execution continues after the "endwhile".

            NOTE: The ":append" and ":insert" commands don't work
            properly inside a ":while" loop.

                            *:continue* *:con*
:con[tinue]        When used inside a ":while", jumps back to the
            ":while".

                            *:break* *:brea*
:brea[k]        When used inside a ":while", skips to the command
            after the matching ":endwhile".

                            *:ec* *:echo*
:ec[ho] {expr1} ..    Echoes each {expr1}, with a space in between and a
            terminating <EOL>.  Also see |:comment|.
            Use "\n" to start a new line.  Use "\r" to move the
            cursor to the first column.
            Cannot be followed by a comment.
            Example: >
        :echo "the value of 'shell' is" &shell
<            A later redraw may make the message disappear again.
            To avoid that a command from before the ":echo" causes
            a redraw afterwards (redraws are often postponed until
            you type something), force a redraw with the |:redraw|
            command.  Example: >
        :new | redraw | echo "there is a new window"
<
                            *:echon*
:echon {expr1} ..    Echoes each {expr1}, without anything added.  Also see
            |:comment|.
            Cannot be followed by a comment.
            Example: >
                :echon "the value of 'shell' is " &shell
<
            Note the difference between using ":echo", which is a
            Vim command, and ":!echo", which is an external shell
            command: >
        :!echo %        --> filename
<            The arguments of ":!" are expanded, see |:_%|. >
        :!echo "%"        --> filename or "filename"
<            Like the previous example.  Whether you see the double
            quotes or not depends on your 'shell'. >
        :echo %            --> nothing
<            The '%' is an illegal character in an expression. >
        :echo "%"        --> %
<            This just echoes the '%' character. >
        :echo expand("%")    --> filename
<            This calls the expand() function to expand the '%'.

                            *:echoh* *:echohl*
:echoh[l] {name}    Use the highlight group {name} for the following
            ":echo[n]" commands.  Example: >
        :echohl WarningMsg | echo "Don't panic!" | echohl None
<            Don't forget to set the group back to "None",
            otherwise all following echo's will be highlighted.

                            *:echom* *:echomsg*
:echom[sg] {expr1} ..    Echo the expression(s) as a true message, saving the
            message in the |message-history|.
            Spaces are placed between the arguments as with the
            :echo command.
            Example: >
        :echomsg "It's a Zizzer Zazzer Zuzz, as you can plainly see."
<
                            *:echoe* *:echoerr*
:echoe[rr] {expr1} ..    Echo the expression(s) as an error message, saving the
            message in the |message-history|.
            Spaces are placed between the arguments as with the
            :echo command.
            Example: >
        :echoerr "This script just failed!"
<
                            *:exe* *:execute*
:exe[cute] {expr1} ..    Executes the string that results from the evaluation
            of {expr1} as an Ex command.  Multiple arguments are
            concatenated, with a space in between.
            Cannot be followed by a comment.
            Examples: >
        :execute "buffer " nextbuf
        :execute "normal " count . "w"
<
            Execute can be used to append a next command to
            commands that don't accept a '|'.  Example: >
        :execute '!ls' | echo "theend"

<            Execute is also a nice way to avoid having to type
            control characters in a Vim script for a ":normal"
            command: >
        :execute "normal ixxx\<Esc>"
<            This has an <Esc> character, see |expr-string|.

            Note: The executed string may be any command-line, but
            you cannot start or end a "while" or "if" command.
            Thus this is illegal: >
        :execute 'while i > 5'
        :execute 'echo "test" | break'
<
            It is allowed to have a "while" or "if" command
            completely in the executed string: >
        :execute 'while i < 5 | echo i | let i = i + 1 | endwhile'
<

                            *:comment*
            ":execute", ":echo" and ":echon" cannot be followed by
            a comment directly, because they see the '"' as the
            start of a string.  But, you can use '|' followed by a
            comment.  Example: >
        :echo "foo" | "this is a comment

==============================================================================
8. Examples                        *eval-examples*

Printing in Hex ~
>
  :" The function Nr2Hex() returns the Hex string of a number.
  :func Nr2Hex(nr)
  :  let n = a:nr
  :  let r = ""
  :  while n
  :    let r = '0123456789ABCDEF'[n % 16] . r
  :    let n = n / 16
  :  endwhile
  :  return r
  :endfunc

  :" The function String2Hex() converts each character in a string to a two
  :" character Hex string.
  :func String2Hex(str)
  :  let out = ''
  :  let ix = 0
  :  while ix < strlen(a:str)
  :    let out = out . Nr2Hex(char2nr(a:str[ix]))
  :    let ix = ix + 1
  :  endwhile
  :  return out
  :endfunc

Example of its use: >
  :echo Nr2Hex(32)
result: "20" >
  :echo String2Hex("32")
result: "3332"


Sorting lines (by Robert Webb) ~

Here is a vim script to sort lines.  Highlight the lines in vim and type
":Sort".  This doesn't call any external programs so it'll work on any
platform.  The function Sort() actually takes the name of a comparison
function as its argument, like qsort() does in C.  So you could supply it
with different comparison functions in order to sort according to date etc.
>
  :" Function for use with Sort(), to compare two strings.
  :func! Strcmp(str1, str2)
  :  if (a:str1 < a:str2)
  :    return -1
  :  elseif (a:str1 > a:str2)
  :    return 1
  :  else
  :    return 0
  :  endif
  :endfunction

  :" Sort lines.  SortR() is called recursively.
  :func! SortR(start, end, cmp)
  :  if (a:start >= a:end)
  :    return
  :  endif
  :  let partition = a:start - 1
  :  let middle = partition
  :  let partStr = getline((a:start + a:end) / 2)
  :  let i = a:start
  :  while (i <= a:end)
  :    let str = getline(i)
  :    exec "let result = " . a:cmp . "(str, partStr)"
  :    if (result <= 0)
  :        " Need to put it before the partition.  Swap lines i and partition.
  :        let partition = partition + 1
  :        if (result == 0)
  :        let middle = partition
  :        endif
  :        if (i != partition)
  :        let str2 = getline(partition)
  :        call setline(i, str2)
  :        call setline(partition, str)
  :        endif
  :    endif
  :    let i = i + 1
  :  endwhile

  :  " Now we have a pointer to the "middle" element, as far as partitioning
  :  " goes, which could be anywhere before the partition.  Make sure it is at
  :  " the end of the partition.
  :  if (middle != partition)
  :    let str = getline(middle)
  :    let str2 = getline(partition)
  :    call setline(middle, str2)
  :    call setline(partition, str)
  :  endif
  :  call SortR(a:start, partition - 1, a:cmp)
  :  call SortR(partition + 1, a:end, a:cmp)
  :endfunc

  :" To Sort a range of lines, pass the range to Sort() along with the name of a
  :" function that will compare two lines.
  :func! Sort(cmp) range
  :  call SortR(a:firstline, a:lastline, a:cmp)
  :endfunc

  :" :Sort takes a range of lines and sorts them.
  :command! -nargs=0 -range Sort <line1>,<line2>call Sort("Strcmp")
<
                            *sscanf*
There is no sscanf() function in Vim.  If you need to extract parts from a
line, you can use matchstr() and substitute() to do it  This example shows
how to get the file name, line number and column number out of a line like
"foobar.txt, 123, 45". >
   :" Set up the match bit
   :let mx='\(\f\+\),\s*\(\d\+\),\s*\(\d\+\)'
   :"get the part matching the whole expression
   :let l = matchstr(line, mx)
   :"get each item out of the match
   :let file = substitute(l, mx, '\1', '')
   :let lnum = substitute(l, mx, '\2', '')
   :let col = substitute(l, mx, '\3', '')

The input is in the variable "line", the results in the variables "file",
"lnum" and "col". (idea from Michael Geddes)

==============================================================================
9. No +eval feature                *no-eval-feature*

When the |+eval| feature was disabled at compile time, none of the expression
evaluation commands are available.  To prevent this from causing Vim scripts
to generate all kinds of errors, the ":if" and ":endif" commands are still
recognized, though the argument of the ":if" and everything between the ":if"
and the matching ":endif" is ignored.  Nesting of ":if" blocks is allowed, but
only if the commands are at the start of the line.  The ":else" command is not
recognized.

Example of how to avoid executing commands when the |+eval| feature is
missing: >

    :if 1
    :  echo "Expression evaluation is compiled in"
    :else
    :  echo "You will _never_ see this message"
    :endif
<
==============================================================================
10. The sandbox                    *eval-sandbox* *sandbox* *E48*

The 'foldexpr', 'includeexpr', 'indentexpr', 'statusline' and 'foldtext'
options are evaluated in a sandbox.  This means that you are protected from
these expression having nasty side effects.  This gives some safety for when
these options are set from a modeline.  It is also used when the command from
a tags file is executed.
This is not guaranteed 100% secure, but it should block most attacks.

These items are not allowed in the sandbox:
    - changing the buffer text
    - defining or changing mapping, autocommands, functions, user commands
    - setting an option with ":set"
    - executing a shell command
    - reading or writing a file
    - jumping to another buffer or editing a file

 vim:tw=78:ts=8:ft=help:norl: